diff --git a/Casadi/Core/Classes/Callback.hs b/Casadi/Core/Classes/Callback.hs
--- a/Casadi/Core/Classes/Callback.hs
+++ b/Casadi/Core/Classes/Callback.hs
@@ -11,6 +11,23 @@
          CallbackClass(..),
          callback__0,
          callback__1,
+         callback_construct__0,
+         callback_construct__1,
+         callback_eval,
+         callback_finalize,
+         callback_get_forward,
+         callback_get_jacobian,
+         callback_get_n_forward,
+         callback_get_n_in,
+         callback_get_n_out,
+         callback_get_n_reverse,
+         callback_get_name_in,
+         callback_get_name_out,
+         callback_get_reverse,
+         callback_get_sparsity_in,
+         callback_get_sparsity_out,
+         callback_has_jacobian,
+         callback_init,
        ) where
 
 
@@ -27,46 +44,551 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__Callback__CONSTRUCTOR__0" c_casadi__Callback__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr IterationCallback' -> IO (Ptr Callback')
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO (Ptr Callback')
+
 casadi__Callback__CONSTRUCTOR__0
-  :: IterationCallback -> IO Callback
-casadi__Callback__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  :: Callback -> IO Callback
+casadi__Callback__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
-callback__0 :: IterationCallback -> IO Callback
+callback__0 :: Callback -> IO Callback
 callback__0 = casadi__Callback__CONSTRUCTOR__0
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__Callback__CONSTRUCTOR__1" c_casadi__Callback__CONSTRUCTOR__1
   :: Ptr (Ptr StdString) -> IO (Ptr Callback')
+
 casadi__Callback__CONSTRUCTOR__1
   :: IO Callback
-casadi__Callback__CONSTRUCTOR__1  =
+casadi__Callback__CONSTRUCTOR__1  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback__CONSTRUCTOR__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__CONSTRUCTOR__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 callback__1 :: IO Callback
 callback__1 = casadi__Callback__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__construct__0" c_casadi__Callback__construct__0
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> Ptr StdString -> IO ()
+
+casadi__Callback__construct__0
+  :: Callback -> String -> IO ()
+casadi__Callback__construct__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__construct__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+callback_construct__0 :: CallbackClass a => a -> String -> IO ()
+callback_construct__0 x = casadi__Callback__construct__0 (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__construct__1" c_casadi__Callback__construct__1
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
+
+casadi__Callback__construct__1
+  :: Callback -> String -> M.Map String GenericType -> IO ()
+casadi__Callback__construct__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__construct__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+callback_construct__1 :: CallbackClass a => a -> String -> M.Map String GenericType -> IO ()
+callback_construct__1 x = casadi__Callback__construct__1 (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__eval" c_casadi__Callback__eval
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> Ptr (StdVec (Ptr DM')) -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi__Callback__eval
+  :: Callback -> Vector DM -> IO (Vector DM)
+casadi__Callback__eval x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__eval errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_eval :: CallbackClass a => a -> Vector DM -> IO (Vector DM)
+callback_eval x = casadi__Callback__eval (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__finalize" c_casadi__Callback__finalize
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO ()
+
+casadi__Callback__finalize
+  :: Callback -> IO ()
+casadi__Callback__finalize x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__finalize errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+callback_finalize :: CallbackClass a => a -> IO ()
+callback_finalize x = casadi__Callback__finalize (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_forward" c_casadi__Callback__get_forward
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Callback__get_forward
+  :: Callback -> String -> Int -> M.Map String GenericType -> IO Function
+casadi__Callback__get_forward x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_forward errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_forward :: CallbackClass a => a -> String -> Int -> M.Map String GenericType -> IO Function
+callback_get_forward x = casadi__Callback__get_forward (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_jacobian" c_casadi__Callback__get_jacobian
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Callback__get_jacobian
+  :: Callback -> String -> M.Map String GenericType -> IO Function
+casadi__Callback__get_jacobian x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_jacobian errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_jacobian :: CallbackClass a => a -> String -> M.Map String GenericType -> IO Function
+callback_get_jacobian x = casadi__Callback__get_jacobian (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_n_forward" c_casadi__Callback__get_n_forward
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO CInt
+
+casadi__Callback__get_n_forward
+  :: Callback -> IO Int
+casadi__Callback__get_n_forward x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_n_forward errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_n_forward :: CallbackClass a => a -> IO Int
+callback_get_n_forward x = casadi__Callback__get_n_forward (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_n_in" c_casadi__Callback__get_n_in
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO CInt
+
+casadi__Callback__get_n_in
+  :: Callback -> IO Int
+casadi__Callback__get_n_in x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_n_in errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_n_in :: CallbackClass a => a -> IO Int
+callback_get_n_in x = casadi__Callback__get_n_in (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_n_out" c_casadi__Callback__get_n_out
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO CInt
+
+casadi__Callback__get_n_out
+  :: Callback -> IO Int
+casadi__Callback__get_n_out x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_n_out errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_n_out :: CallbackClass a => a -> IO Int
+callback_get_n_out x = casadi__Callback__get_n_out (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_n_reverse" c_casadi__Callback__get_n_reverse
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO CInt
+
+casadi__Callback__get_n_reverse
+  :: Callback -> IO Int
+casadi__Callback__get_n_reverse x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_n_reverse errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_n_reverse :: CallbackClass a => a -> IO Int
+callback_get_n_reverse x = casadi__Callback__get_n_reverse (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_name_in" c_casadi__Callback__get_name_in
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> CInt -> IO (Ptr StdString)
+
+casadi__Callback__get_name_in
+  :: Callback -> Int -> IO String
+casadi__Callback__get_name_in x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_name_in errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_name_in :: CallbackClass a => a -> Int -> IO String
+callback_get_name_in x = casadi__Callback__get_name_in (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_name_out" c_casadi__Callback__get_name_out
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> CInt -> IO (Ptr StdString)
+
+casadi__Callback__get_name_out
+  :: Callback -> Int -> IO String
+casadi__Callback__get_name_out x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_name_out errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_name_out :: CallbackClass a => a -> Int -> IO String
+callback_get_name_out x = casadi__Callback__get_name_out (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_reverse" c_casadi__Callback__get_reverse
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Callback__get_reverse
+  :: Callback -> String -> Int -> M.Map String GenericType -> IO Function
+casadi__Callback__get_reverse x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_reverse errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_reverse :: CallbackClass a => a -> String -> Int -> M.Map String GenericType -> IO Function
+callback_get_reverse x = casadi__Callback__get_reverse (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_sparsity_in" c_casadi__Callback__get_sparsity_in
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Callback__get_sparsity_in
+  :: Callback -> Int -> IO Sparsity
+casadi__Callback__get_sparsity_in x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_sparsity_in errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_sparsity_in :: CallbackClass a => a -> Int -> IO Sparsity
+callback_get_sparsity_in x = casadi__Callback__get_sparsity_in (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__get_sparsity_out" c_casadi__Callback__get_sparsity_out
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Callback__get_sparsity_out
+  :: Callback -> Int -> IO Sparsity
+casadi__Callback__get_sparsity_out x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__get_sparsity_out errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_get_sparsity_out :: CallbackClass a => a -> Int -> IO Sparsity
+callback_get_sparsity_out x = casadi__Callback__get_sparsity_out (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__has_jacobian" c_casadi__Callback__has_jacobian
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO CInt
+
+casadi__Callback__has_jacobian
+  :: Callback -> IO Bool
+casadi__Callback__has_jacobian x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__has_jacobian errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+callback_has_jacobian :: CallbackClass a => a -> IO Bool
+callback_has_jacobian x = casadi__Callback__has_jacobian (castCallback x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Callback__init" c_casadi__Callback__init
+  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO ()
+
+casadi__Callback__init
+  :: Callback -> IO ()
+casadi__Callback__init x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Callback__init errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+callback_init :: CallbackClass a => a -> IO ()
+callback_init x = casadi__Callback__init (castCallback x)
 
diff --git a/Casadi/Core/Classes/Callback2.hs b/Casadi/Core/Classes/Callback2.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/Callback2.hs
+++ /dev/null
@@ -1,266 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.Callback2
-       (
-         Callback2,
-         Callback2Class(..),
-         callback2,
-         callback2_create,
-         callback2_inputShape,
-         callback2_inputSparsity,
-         callback2_nIn,
-         callback2_nOut,
-         callback2_name,
-         callback2_operator_call,
-         callback2_options,
-         callback2_outputShape,
-         callback2_outputSparsity,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__CONSTRUCTOR" c_casadi__Callback2__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr Callback2')
-casadi__Callback2__CONSTRUCTOR
-  :: IO Callback2
-casadi__Callback2__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2 :: IO Callback2
-callback2 = casadi__Callback2__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__create" c_casadi__Callback2__create
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO (Ptr Function')
-casadi__Callback2__create
-  :: Callback2 -> IO Function
-casadi__Callback2__create x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__create errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_create :: Callback2Class a => a -> IO Function
-callback2_create x = casadi__Callback2__create (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__inputShape" c_casadi__Callback2__inputShape
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr (StdPair CInt CInt))
-casadi__Callback2__inputShape
-  :: Callback2 -> Int -> IO (Int, Int)
-casadi__Callback2__inputShape x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__inputShape errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_inputShape :: Callback2Class a => a -> Int -> IO (Int, Int)
-callback2_inputShape x = casadi__Callback2__inputShape (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__inputSparsity" c_casadi__Callback2__inputSparsity
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr Sparsity')
-casadi__Callback2__inputSparsity
-  :: Callback2 -> Int -> IO Sparsity
-casadi__Callback2__inputSparsity x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__inputSparsity errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_inputSparsity :: Callback2Class a => a -> Int -> IO Sparsity
-callback2_inputSparsity x = casadi__Callback2__inputSparsity (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__nIn" c_casadi__Callback2__nIn
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO CInt
-casadi__Callback2__nIn
-  :: Callback2 -> IO Int
-casadi__Callback2__nIn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__nIn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_nIn :: Callback2Class a => a -> IO Int
-callback2_nIn x = casadi__Callback2__nIn (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__nOut" c_casadi__Callback2__nOut
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO CInt
-casadi__Callback2__nOut
-  :: Callback2 -> IO Int
-casadi__Callback2__nOut x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__nOut errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_nOut :: Callback2Class a => a -> IO Int
-callback2_nOut x = casadi__Callback2__nOut (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__name" c_casadi__Callback2__name
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO (Ptr StdString)
-casadi__Callback2__name
-  :: Callback2 -> IO String
-casadi__Callback2__name x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__name errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_name :: Callback2Class a => a -> IO String
-callback2_name x = casadi__Callback2__name (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__operator_call" c_casadi__Callback2__operator_call
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi__Callback2__operator_call
-  :: Callback2 -> Vector DMatrix -> IO (Vector DMatrix)
-casadi__Callback2__operator_call x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__operator_call errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_operator_call :: Callback2Class a => a -> Vector DMatrix -> IO (Vector DMatrix)
-callback2_operator_call x = casadi__Callback2__operator_call (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__options" c_casadi__Callback2__options
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO (Ptr (StdMap StdString (Ptr GenericType')))
-casadi__Callback2__options
-  :: Callback2 -> IO (M.Map String GenericType)
-casadi__Callback2__options x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__options errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_options :: Callback2Class a => a -> IO (M.Map String GenericType)
-callback2_options x = casadi__Callback2__options (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__outputShape" c_casadi__Callback2__outputShape
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr (StdPair CInt CInt))
-casadi__Callback2__outputShape
-  :: Callback2 -> Int -> IO (Int, Int)
-casadi__Callback2__outputShape x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__outputShape errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_outputShape :: Callback2Class a => a -> Int -> IO (Int, Int)
-callback2_outputShape x = casadi__Callback2__outputShape (castCallback2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Callback2__outputSparsity" c_casadi__Callback2__outputSparsity
-  :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr Sparsity')
-casadi__Callback2__outputSparsity
-  :: Callback2 -> Int -> IO Sparsity
-casadi__Callback2__outputSparsity x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Callback2__outputSparsity errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-callback2_outputSparsity :: Callback2Class a => a -> Int -> IO Sparsity
-callback2_outputSparsity x = casadi__Callback2__outputSparsity (castCallback2 x)
-
diff --git a/Casadi/Core/Classes/CasadiMeta.hs b/Casadi/Core/Classes/CasadiMeta.hs
--- a/Casadi/Core/Classes/CasadiMeta.hs
+++ b/Casadi/Core/Classes/CasadiMeta.hs
@@ -36,25 +36,32 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getBuildType" c_casadi__CasadiMeta__getBuildType
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getBuildType
   :: IO String
-casadi__CasadiMeta__getBuildType  =
+casadi__CasadiMeta__getBuildType  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getBuildType errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getBuildType errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getBuildType :: IO String
 casadiMeta_getBuildType = casadi__CasadiMeta__getBuildType
@@ -63,18 +70,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getCompiler" c_casadi__CasadiMeta__getCompiler
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getCompiler
   :: IO String
-casadi__CasadiMeta__getCompiler  =
+casadi__CasadiMeta__getCompiler  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getCompiler errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getCompiler errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getCompiler :: IO String
 casadiMeta_getCompiler = casadi__CasadiMeta__getCompiler
@@ -83,18 +97,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getCompilerFlags" c_casadi__CasadiMeta__getCompilerFlags
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getCompilerFlags
   :: IO String
-casadi__CasadiMeta__getCompilerFlags  =
+casadi__CasadiMeta__getCompilerFlags  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getCompilerFlags errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getCompilerFlags errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getCompilerFlags :: IO String
 casadiMeta_getCompilerFlags = casadi__CasadiMeta__getCompilerFlags
@@ -103,18 +124,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getCompilerId" c_casadi__CasadiMeta__getCompilerId
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getCompilerId
   :: IO String
-casadi__CasadiMeta__getCompilerId  =
+casadi__CasadiMeta__getCompilerId  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getCompilerId errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getCompilerId errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getCompilerId :: IO String
 casadiMeta_getCompilerId = casadi__CasadiMeta__getCompilerId
@@ -123,18 +151,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getFeatureList" c_casadi__CasadiMeta__getFeatureList
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getFeatureList
   :: IO String
-casadi__CasadiMeta__getFeatureList  =
+casadi__CasadiMeta__getFeatureList  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getFeatureList errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getFeatureList errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getFeatureList :: IO String
 casadiMeta_getFeatureList = casadi__CasadiMeta__getFeatureList
@@ -143,18 +178,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getGitDescribe" c_casadi__CasadiMeta__getGitDescribe
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getGitDescribe
   :: IO String
-casadi__CasadiMeta__getGitDescribe  =
+casadi__CasadiMeta__getGitDescribe  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getGitDescribe errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getGitDescribe errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getGitDescribe :: IO String
 casadiMeta_getGitDescribe = casadi__CasadiMeta__getGitDescribe
@@ -163,18 +205,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getGitRevision" c_casadi__CasadiMeta__getGitRevision
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getGitRevision
   :: IO String
-casadi__CasadiMeta__getGitRevision  =
+casadi__CasadiMeta__getGitRevision  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getGitRevision errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getGitRevision errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getGitRevision :: IO String
 casadiMeta_getGitRevision = casadi__CasadiMeta__getGitRevision
@@ -183,18 +232,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getInstallPrefix" c_casadi__CasadiMeta__getInstallPrefix
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getInstallPrefix
   :: IO String
-casadi__CasadiMeta__getInstallPrefix  =
+casadi__CasadiMeta__getInstallPrefix  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getInstallPrefix errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getInstallPrefix errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getInstallPrefix :: IO String
 casadiMeta_getInstallPrefix = casadi__CasadiMeta__getInstallPrefix
@@ -203,18 +259,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getModules" c_casadi__CasadiMeta__getModules
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getModules
   :: IO String
-casadi__CasadiMeta__getModules  =
+casadi__CasadiMeta__getModules  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getModules errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getModules errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getModules :: IO String
 casadiMeta_getModules = casadi__CasadiMeta__getModules
@@ -223,18 +286,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getPlugins" c_casadi__CasadiMeta__getPlugins
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getPlugins
   :: IO String
-casadi__CasadiMeta__getPlugins  =
+casadi__CasadiMeta__getPlugins  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getPlugins errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getPlugins errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 casadiMeta_getPlugins :: IO String
 casadiMeta_getPlugins = casadi__CasadiMeta__getPlugins
@@ -243,16 +313,23 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CasadiMeta__getVersion" c_casadi__CasadiMeta__getVersion
   :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
 casadi__CasadiMeta__getVersion
   :: IO String
-casadi__CasadiMeta__getVersion  =
+casadi__CasadiMeta__getVersion  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiMeta__getVersion errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CasadiMeta__getVersion errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/CasadiOptions.hs b/Casadi/Core/Classes/CasadiOptions.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/CasadiOptions.hs
+++ /dev/null
@@ -1,324 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.CasadiOptions
-       (
-         CasadiOptions,
-         CasadiOptionsClass(..),
-         casadiOptions_getAllowedInternalAPI,
-         casadiOptions_getCasadiPath,
-         casadiOptions_getCatchErrorsSwig,
-         casadiOptions_getProfilingBinary,
-         casadiOptions_getSimplificationOnTheFly,
-         casadiOptions_setAllowedInternalAPI,
-         casadiOptions_setCasadiPath,
-         casadiOptions_setCatchErrorsSwig,
-         casadiOptions_setProfilingBinary,
-         casadiOptions_setPurgeSeeds__0,
-         casadiOptions_setPurgeSeeds__1,
-         casadiOptions_setSimplificationOnTheFly,
-         casadiOptions_startProfiling,
-         casadiOptions_stopProfiling,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__getAllowedInternalAPI" c_casadi__CasadiOptions__getAllowedInternalAPI
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__CasadiOptions__getAllowedInternalAPI
-  :: IO Bool
-casadi__CasadiOptions__getAllowedInternalAPI  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__getAllowedInternalAPI errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_getAllowedInternalAPI :: IO Bool
-casadiOptions_getAllowedInternalAPI = casadi__CasadiOptions__getAllowedInternalAPI
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__getCasadiPath" c_casadi__CasadiOptions__getCasadiPath
-  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
-casadi__CasadiOptions__getCasadiPath
-  :: IO String
-casadi__CasadiOptions__getCasadiPath  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__getCasadiPath errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_getCasadiPath :: IO String
-casadiOptions_getCasadiPath = casadi__CasadiOptions__getCasadiPath
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__getCatchErrorsSwig" c_casadi__CasadiOptions__getCatchErrorsSwig
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__CasadiOptions__getCatchErrorsSwig
-  :: IO Bool
-casadi__CasadiOptions__getCatchErrorsSwig  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__getCatchErrorsSwig errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_getCatchErrorsSwig :: IO Bool
-casadiOptions_getCatchErrorsSwig = casadi__CasadiOptions__getCatchErrorsSwig
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__getProfilingBinary" c_casadi__CasadiOptions__getProfilingBinary
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__CasadiOptions__getProfilingBinary
-  :: IO Bool
-casadi__CasadiOptions__getProfilingBinary  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__getProfilingBinary errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_getProfilingBinary :: IO Bool
-casadiOptions_getProfilingBinary = casadi__CasadiOptions__getProfilingBinary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__getSimplificationOnTheFly" c_casadi__CasadiOptions__getSimplificationOnTheFly
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__CasadiOptions__getSimplificationOnTheFly
-  :: IO Bool
-casadi__CasadiOptions__getSimplificationOnTheFly  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__getSimplificationOnTheFly errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_getSimplificationOnTheFly :: IO Bool
-casadiOptions_getSimplificationOnTheFly = casadi__CasadiOptions__getSimplificationOnTheFly
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setAllowedInternalAPI" c_casadi__CasadiOptions__setAllowedInternalAPI
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__CasadiOptions__setAllowedInternalAPI
-  :: Bool -> IO ()
-casadi__CasadiOptions__setAllowedInternalAPI x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__setAllowedInternalAPI errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_setAllowedInternalAPI :: Bool -> IO ()
-casadiOptions_setAllowedInternalAPI = casadi__CasadiOptions__setAllowedInternalAPI
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setCasadiPath" c_casadi__CasadiOptions__setCasadiPath
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__CasadiOptions__setCasadiPath
-  :: String -> IO ()
-casadi__CasadiOptions__setCasadiPath x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__setCasadiPath errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_setCasadiPath :: String -> IO ()
-casadiOptions_setCasadiPath = casadi__CasadiOptions__setCasadiPath
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setCatchErrorsSwig" c_casadi__CasadiOptions__setCatchErrorsSwig
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__CasadiOptions__setCatchErrorsSwig
-  :: Bool -> IO ()
-casadi__CasadiOptions__setCatchErrorsSwig x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__setCatchErrorsSwig errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_setCatchErrorsSwig :: Bool -> IO ()
-casadiOptions_setCatchErrorsSwig = casadi__CasadiOptions__setCatchErrorsSwig
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setProfilingBinary" c_casadi__CasadiOptions__setProfilingBinary
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__CasadiOptions__setProfilingBinary
-  :: Bool -> IO ()
-casadi__CasadiOptions__setProfilingBinary x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__setProfilingBinary errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_setProfilingBinary :: Bool -> IO ()
-casadiOptions_setProfilingBinary = casadi__CasadiOptions__setProfilingBinary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setPurgeSeeds__0" c_casadi__CasadiOptions__setPurgeSeeds__0
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__CasadiOptions__setPurgeSeeds__0
-  :: IO Bool
-casadi__CasadiOptions__setPurgeSeeds__0  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__setPurgeSeeds__0 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_setPurgeSeeds__0 :: IO Bool
-casadiOptions_setPurgeSeeds__0 = casadi__CasadiOptions__setPurgeSeeds__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setPurgeSeeds__1" c_casadi__CasadiOptions__setPurgeSeeds__1
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__CasadiOptions__setPurgeSeeds__1
-  :: Bool -> IO ()
-casadi__CasadiOptions__setPurgeSeeds__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__setPurgeSeeds__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_setPurgeSeeds__1 :: Bool -> IO ()
-casadiOptions_setPurgeSeeds__1 = casadi__CasadiOptions__setPurgeSeeds__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setSimplificationOnTheFly" c_casadi__CasadiOptions__setSimplificationOnTheFly
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__CasadiOptions__setSimplificationOnTheFly
-  :: Bool -> IO ()
-casadi__CasadiOptions__setSimplificationOnTheFly x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__setSimplificationOnTheFly errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_setSimplificationOnTheFly :: Bool -> IO ()
-casadiOptions_setSimplificationOnTheFly = casadi__CasadiOptions__setSimplificationOnTheFly
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__startProfiling" c_casadi__CasadiOptions__startProfiling
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__CasadiOptions__startProfiling
-  :: String -> IO ()
-casadi__CasadiOptions__startProfiling x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__startProfiling errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_startProfiling :: String -> IO ()
-casadiOptions_startProfiling = casadi__CasadiOptions__startProfiling
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__stopProfiling" c_casadi__CasadiOptions__stopProfiling
-  :: Ptr (Ptr StdString) -> IO ()
-casadi__CasadiOptions__stopProfiling
-  :: IO ()
-casadi__CasadiOptions__stopProfiling  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CasadiOptions__stopProfiling errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-casadiOptions_stopProfiling :: IO ()
-casadiOptions_stopProfiling = casadi__CasadiOptions__stopProfiling
-
diff --git a/Casadi/Core/Classes/CleSolver.hs b/Casadi/Core/Classes/CleSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/CleSolver.hs
+++ /dev/null
@@ -1,203 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.CleSolver
-       (
-         CleSolver,
-         CleSolverClass(..),
-         cleSolver__0,
-         cleSolver__1,
-         cleSolver__2,
-         cleSolver_clone,
-         cleSolver_doc,
-         cleSolver_hasPlugin,
-         cleSolver_loadPlugin,
-         cleSolver_printStats,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__CONSTRUCTOR__0" c_casadi__CleSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr CleSolver')
-casadi__CleSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO CleSolver
-casadi__CleSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver__0 :: String -> String -> M.Map String Sparsity -> IO CleSolver
-cleSolver__0 = casadi__CleSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__CONSTRUCTOR__1" c_casadi__CleSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CleSolver')
-casadi__CleSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO CleSolver
-casadi__CleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO CleSolver
-cleSolver__1 = casadi__CleSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__CONSTRUCTOR__2" c_casadi__CleSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr CleSolver')
-casadi__CleSolver__CONSTRUCTOR__2
-  :: IO CleSolver
-casadi__CleSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver__2 :: IO CleSolver
-cleSolver__2 = casadi__CleSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__clone" c_casadi__CleSolver__clone
-  :: Ptr (Ptr StdString) -> Ptr CleSolver' -> IO (Ptr CleSolver')
-casadi__CleSolver__clone
-  :: CleSolver -> IO CleSolver
-casadi__CleSolver__clone x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__clone errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver_clone :: CleSolverClass a => a -> IO CleSolver
-cleSolver_clone x = casadi__CleSolver__clone (castCleSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__doc" c_casadi__CleSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__CleSolver__doc
-  :: String -> IO String
-casadi__CleSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver_doc :: String -> IO String
-cleSolver_doc = casadi__CleSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__hasPlugin" c_casadi__CleSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__CleSolver__hasPlugin
-  :: String -> IO Bool
-casadi__CleSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver_hasPlugin :: String -> IO Bool
-cleSolver_hasPlugin = casadi__CleSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__loadPlugin" c_casadi__CleSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__CleSolver__loadPlugin
-  :: String -> IO ()
-casadi__CleSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver_loadPlugin :: String -> IO ()
-cleSolver_loadPlugin = casadi__CleSolver__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CleSolver__printStats" c_casadi__CleSolver__printStats
-  :: Ptr (Ptr StdString) -> Ptr CleSolver' -> IO ()
-casadi__CleSolver__printStats
-  :: CleSolver -> IO ()
-casadi__CleSolver__printStats x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CleSolver__printStats errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-cleSolver_printStats :: CleSolverClass a => a -> IO ()
-cleSolver_printStats x = casadi__CleSolver__printStats (castCleSolver x)
-
diff --git a/Casadi/Core/Classes/CodeGenerator.hs b/Casadi/Core/Classes/CodeGenerator.hs
--- a/Casadi/Core/Classes/CodeGenerator.hs
+++ b/Casadi/Core/Classes/CodeGenerator.hs
@@ -11,11 +11,10 @@
          CodeGeneratorClass(..),
          codeGenerator__0,
          codeGenerator__1,
+         codeGenerator_add,
          codeGenerator_addInclude__0,
          codeGenerator_addInclude__1,
          codeGenerator_addInclude__2,
-         codeGenerator_add__0,
-         codeGenerator_add__1,
          codeGenerator_compile__0,
          codeGenerator_compile__1,
          codeGenerator_generate__0,
@@ -36,25 +35,32 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__CONSTRUCTOR__0" c_casadi__CodeGenerator__CONSTRUCTOR__0
   :: Ptr (Ptr StdString) -> IO (Ptr CodeGenerator')
+
 casadi__CodeGenerator__CONSTRUCTOR__0
   :: IO CodeGenerator
-casadi__CodeGenerator__CONSTRUCTOR__0  =
+casadi__CodeGenerator__CONSTRUCTOR__0  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__CONSTRUCTOR__0 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__CONSTRUCTOR__0 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 codeGenerator__0 :: IO CodeGenerator
 codeGenerator__0 = casadi__CodeGenerator__CONSTRUCTOR__0
@@ -63,82 +69,83 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__CONSTRUCTOR__1" c_casadi__CodeGenerator__CONSTRUCTOR__1
   :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CodeGenerator')
+
 casadi__CodeGenerator__CONSTRUCTOR__1
   :: M.Map String GenericType -> IO CodeGenerator
-casadi__CodeGenerator__CONSTRUCTOR__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__CONSTRUCTOR__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__CONSTRUCTOR__1 x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__CONSTRUCTOR__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
--- classy wrapper
-codeGenerator__1 :: M.Map String GenericType -> IO CodeGenerator
-codeGenerator__1 = casadi__CodeGenerator__CONSTRUCTOR__1
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
+  marshalFree x0 x0'
 
--- direct wrapper
-foreign import ccall unsafe "casadi__CodeGenerator__add__0" c_casadi__CodeGenerator__add__0
-  :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr Function' -> Ptr StdString -> IO ()
-casadi__CodeGenerator__add__0
-  :: CodeGenerator -> Function -> String -> IO ()
-casadi__CodeGenerator__add__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__add__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  return ret
 
 
+
 -- classy wrapper
-codeGenerator_add__0 :: CodeGeneratorClass a => a -> Function -> String -> IO ()
-codeGenerator_add__0 x = casadi__CodeGenerator__add__0 (castCodeGenerator x)
+codeGenerator__1 :: M.Map String GenericType -> IO CodeGenerator
+codeGenerator__1 = casadi__CodeGenerator__CONSTRUCTOR__1
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__CodeGenerator__add__1" c_casadi__CodeGenerator__add__1
+foreign import ccall unsafe "casadi__CodeGenerator__add" c_casadi__CodeGenerator__add
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr Function' -> IO ()
-casadi__CodeGenerator__add__1
+
+casadi__CodeGenerator__add
   :: CodeGenerator -> Function -> IO ()
-casadi__CodeGenerator__add__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__add__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__add x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__add errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
 -- classy wrapper
-codeGenerator_add__1 :: CodeGeneratorClass a => a -> Function -> IO ()
-codeGenerator_add__1 x = casadi__CodeGenerator__add__1 (castCodeGenerator x)
+codeGenerator_add :: CodeGeneratorClass a => a -> Function -> IO ()
+codeGenerator_add x = casadi__CodeGenerator__add (castCodeGenerator x)
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__addInclude__0" c_casadi__CodeGenerator__addInclude__0
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> IO ()
+
 casadi__CodeGenerator__addInclude__0
   :: CodeGenerator -> String -> IO ()
-casadi__CodeGenerator__addInclude__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__addInclude__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__addInclude__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__addInclude__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
 -- classy wrapper
 codeGenerator_addInclude__0 :: CodeGeneratorClass a => a -> String -> IO ()
 codeGenerator_addInclude__0 x = casadi__CodeGenerator__addInclude__0 (castCodeGenerator x)
@@ -147,20 +154,29 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__addInclude__1" c_casadi__CodeGenerator__addInclude__1
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> CInt -> IO ()
+
 casadi__CodeGenerator__addInclude__1
   :: CodeGenerator -> String -> Bool -> IO ()
-casadi__CodeGenerator__addInclude__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__addInclude__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__addInclude__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__addInclude__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
 -- classy wrapper
 codeGenerator_addInclude__1 :: CodeGeneratorClass a => a -> String -> Bool -> IO ()
 codeGenerator_addInclude__1 x = casadi__CodeGenerator__addInclude__1 (castCodeGenerator x)
@@ -169,21 +185,31 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__addInclude__2" c_casadi__CodeGenerator__addInclude__2
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> CInt -> Ptr StdString -> IO ()
+
 casadi__CodeGenerator__addInclude__2
   :: CodeGenerator -> String -> Bool -> String -> IO ()
-casadi__CodeGenerator__addInclude__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__addInclude__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__addInclude__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__addInclude__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
 -- classy wrapper
 codeGenerator_addInclude__2 :: CodeGeneratorClass a => a -> String -> Bool -> String -> IO ()
 codeGenerator_addInclude__2 x = casadi__CodeGenerator__addInclude__2 (castCodeGenerator x)
@@ -192,19 +218,27 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__compile__0" c_casadi__CodeGenerator__compile__0
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> IO (Ptr StdString)
+
 casadi__CodeGenerator__compile__0
   :: CodeGenerator -> String -> IO String
-casadi__CodeGenerator__compile__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__compile__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__compile__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__compile__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
 codeGenerator_compile__0 :: CodeGeneratorClass a => a -> String -> IO String
 codeGenerator_compile__0 x = casadi__CodeGenerator__compile__0 (castCodeGenerator x)
@@ -213,20 +247,29 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__compile__1" c_casadi__CodeGenerator__compile__1
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> Ptr StdString -> IO (Ptr StdString)
+
 casadi__CodeGenerator__compile__1
   :: CodeGenerator -> String -> String -> IO String
-casadi__CodeGenerator__compile__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__compile__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__compile__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__compile__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
 -- classy wrapper
 codeGenerator_compile__1 :: CodeGeneratorClass a => a -> String -> String -> IO String
 codeGenerator_compile__1 x = casadi__CodeGenerator__compile__1 (castCodeGenerator x)
@@ -235,18 +278,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__generate__0" c_casadi__CodeGenerator__generate__0
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> IO (Ptr StdString)
+
 casadi__CodeGenerator__generate__0
   :: CodeGenerator -> IO String
-casadi__CodeGenerator__generate__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__generate__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__generate__0 x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__generate__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 codeGenerator_generate__0 :: CodeGeneratorClass a => a -> IO String
 codeGenerator_generate__0 x = casadi__CodeGenerator__generate__0 (castCodeGenerator x)
@@ -255,17 +305,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__CodeGenerator__generate__1" c_casadi__CodeGenerator__generate__1
   :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> IO ()
+
 casadi__CodeGenerator__generate__1
   :: CodeGenerator -> String -> IO ()
-casadi__CodeGenerator__generate__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CodeGenerator__generate__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__CodeGenerator__generate__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__CodeGenerator__generate__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/Compiler.hs b/Casadi/Core/Classes/Compiler.hs
--- a/Casadi/Core/Classes/Compiler.hs
+++ b/Casadi/Core/Classes/Compiler.hs
@@ -32,26 +32,34 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__Compiler__CONSTRUCTOR__0" c_casadi__Compiler__CONSTRUCTOR__0
   :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr Compiler')
+
 casadi__Compiler__CONSTRUCTOR__0
   :: String -> String -> IO Compiler
-casadi__Compiler__CONSTRUCTOR__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Compiler__CONSTRUCTOR__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Compiler__CONSTRUCTOR__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Compiler__CONSTRUCTOR__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
 compiler__0 :: String -> String -> IO Compiler
 compiler__0 = casadi__Compiler__CONSTRUCTOR__0
@@ -60,20 +68,29 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Compiler__CONSTRUCTOR__1" c_casadi__Compiler__CONSTRUCTOR__1
   :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Compiler')
+
 casadi__Compiler__CONSTRUCTOR__1
   :: String -> String -> M.Map String GenericType -> IO Compiler
-casadi__Compiler__CONSTRUCTOR__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Compiler__CONSTRUCTOR__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Compiler__CONSTRUCTOR__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Compiler__CONSTRUCTOR__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
 -- classy wrapper
 compiler__1 :: String -> String -> M.Map String GenericType -> IO Compiler
 compiler__1 = casadi__Compiler__CONSTRUCTOR__1
@@ -82,18 +99,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Compiler__CONSTRUCTOR__2" c_casadi__Compiler__CONSTRUCTOR__2
   :: Ptr (Ptr StdString) -> IO (Ptr Compiler')
+
 casadi__Compiler__CONSTRUCTOR__2
   :: IO Compiler
-casadi__Compiler__CONSTRUCTOR__2  =
+casadi__Compiler__CONSTRUCTOR__2  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Compiler__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Compiler__CONSTRUCTOR__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 compiler__2 :: IO Compiler
 compiler__2 = casadi__Compiler__CONSTRUCTOR__2
@@ -102,18 +126,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Compiler__doc" c_casadi__Compiler__doc
   :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
 casadi__Compiler__doc
   :: String -> IO String
-casadi__Compiler__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Compiler__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Compiler__doc x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Compiler__doc errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 compiler_doc :: String -> IO String
 compiler_doc = casadi__Compiler__doc
@@ -122,18 +153,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Compiler__hasPlugin" c_casadi__Compiler__hasPlugin
   :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
+
 casadi__Compiler__hasPlugin
   :: String -> IO Bool
-casadi__Compiler__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Compiler__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Compiler__hasPlugin x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Compiler__hasPlugin errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 compiler_hasPlugin :: String -> IO Bool
 compiler_hasPlugin = casadi__Compiler__hasPlugin
@@ -142,18 +180,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Compiler__loadPlugin" c_casadi__Compiler__loadPlugin
   :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
 casadi__Compiler__loadPlugin
   :: String -> IO ()
-casadi__Compiler__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Compiler__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Compiler__loadPlugin x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Compiler__loadPlugin errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
 -- classy wrapper
 compiler_loadPlugin :: String -> IO ()
 compiler_loadPlugin = casadi__Compiler__loadPlugin
@@ -162,16 +207,23 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Compiler__plugin_name" c_casadi__Compiler__plugin_name
   :: Ptr (Ptr StdString) -> Ptr Compiler' -> IO (Ptr StdString)
+
 casadi__Compiler__plugin_name
   :: Compiler -> IO String
-casadi__Compiler__plugin_name x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Compiler__plugin_name errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Compiler__plugin_name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Compiler__plugin_name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/ControlSimulator.hs b/Casadi/Core/Classes/ControlSimulator.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/ControlSimulator.hs
+++ /dev/null
@@ -1,210 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.ControlSimulator
-       (
-         ControlSimulator,
-         ControlSimulatorClass(..),
-         controlSimulator__0,
-         controlSimulator__1,
-         controlSimulator__2,
-         controlSimulator__3,
-         controlSimulator__4,
-         controlSimulator_getMajorIndex,
-         controlSimulator_getMinorT,
-         controlSimulator_getMinorU,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__0" c_casadi__ControlSimulator__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr ControlSimulator')
-casadi__ControlSimulator__CONSTRUCTOR__0
-  :: String -> Function -> DMatrix -> IO ControlSimulator
-casadi__ControlSimulator__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator__0 :: String -> Function -> DMatrix -> IO ControlSimulator
-controlSimulator__0 = casadi__ControlSimulator__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__1" c_casadi__ControlSimulator__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ControlSimulator')
-casadi__ControlSimulator__CONSTRUCTOR__1
-  :: String -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator
-casadi__ControlSimulator__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator__1 :: String -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator
-controlSimulator__1 = casadi__ControlSimulator__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__2" c_casadi__ControlSimulator__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr ControlSimulator')
-casadi__ControlSimulator__CONSTRUCTOR__2
-  :: String -> Function -> Function -> DMatrix -> IO ControlSimulator
-casadi__ControlSimulator__CONSTRUCTOR__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator__2 :: String -> Function -> Function -> DMatrix -> IO ControlSimulator
-controlSimulator__2 = casadi__ControlSimulator__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__3" c_casadi__ControlSimulator__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ControlSimulator')
-casadi__ControlSimulator__CONSTRUCTOR__3
-  :: String -> Function -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator
-casadi__ControlSimulator__CONSTRUCTOR__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator__3 :: String -> Function -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator
-controlSimulator__3 = casadi__ControlSimulator__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__4" c_casadi__ControlSimulator__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> IO (Ptr ControlSimulator')
-casadi__ControlSimulator__CONSTRUCTOR__4
-  :: IO ControlSimulator
-casadi__ControlSimulator__CONSTRUCTOR__4  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__CONSTRUCTOR__4 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator__4 :: IO ControlSimulator
-controlSimulator__4 = casadi__ControlSimulator__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__getMajorIndex" c_casadi__ControlSimulator__getMajorIndex
-  :: Ptr (Ptr StdString) -> Ptr ControlSimulator' -> IO (Ptr (StdVec CInt))
-casadi__ControlSimulator__getMajorIndex
-  :: ControlSimulator -> IO (Vector Int)
-casadi__ControlSimulator__getMajorIndex x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__getMajorIndex errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator_getMajorIndex :: ControlSimulatorClass a => a -> IO (Vector Int)
-controlSimulator_getMajorIndex x = casadi__ControlSimulator__getMajorIndex (castControlSimulator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__getMinorT" c_casadi__ControlSimulator__getMinorT
-  :: Ptr (Ptr StdString) -> Ptr ControlSimulator' -> IO (Ptr (StdVec CDouble))
-casadi__ControlSimulator__getMinorT
-  :: ControlSimulator -> IO (Vector Double)
-casadi__ControlSimulator__getMinorT x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__getMinorT errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator_getMinorT :: ControlSimulatorClass a => a -> IO (Vector Double)
-controlSimulator_getMinorT x = casadi__ControlSimulator__getMinorT (castControlSimulator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ControlSimulator__getMinorU" c_casadi__ControlSimulator__getMinorU
-  :: Ptr (Ptr StdString) -> Ptr ControlSimulator' -> IO (Ptr DMatrix')
-casadi__ControlSimulator__getMinorU
-  :: ControlSimulator -> IO DMatrix
-casadi__ControlSimulator__getMinorU x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ControlSimulator__getMinorU errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-controlSimulator_getMinorU :: ControlSimulatorClass a => a -> IO DMatrix
-controlSimulator_getMinorU x = casadi__ControlSimulator__getMinorU (castControlSimulator x)
-
diff --git a/Casadi/Core/Classes/CustomEvaluate.hs b/Casadi/Core/Classes/CustomEvaluate.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/CustomEvaluate.hs
+++ /dev/null
@@ -1,51 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.CustomEvaluate
-       (
-         CustomEvaluate,
-         CustomEvaluateClass(..),
-         customEvaluate,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomEvaluate__CONSTRUCTOR" c_casadi__CustomEvaluate__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr CustomEvaluate')
-casadi__CustomEvaluate__CONSTRUCTOR
-  :: IO CustomEvaluate
-casadi__CustomEvaluate__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomEvaluate__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customEvaluate :: IO CustomEvaluate
-customEvaluate = casadi__CustomEvaluate__CONSTRUCTOR
-
diff --git a/Casadi/Core/Classes/CustomFunction.hs b/Casadi/Core/Classes/CustomFunction.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/CustomFunction.hs
+++ /dev/null
@@ -1,247 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.CustomFunction
-       (
-         CustomFunction,
-         CustomFunctionClass(..),
-         customFunction__0,
-         customFunction__1,
-         customFunction__2,
-         customFunction__3,
-         customFunction__4,
-         customFunction__5,
-         customFunction__6,
-         customFunction__7,
-         customFunction__8,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__0" c_casadi__CustomFunction__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__0
-  :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__0 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> IO CustomFunction
-customFunction__0 = casadi__CustomFunction__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__1" c_casadi__CustomFunction__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__1
-  :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__1 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction
-customFunction__1 = casadi__CustomFunction__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__2" c_casadi__CustomFunction__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__2
-  :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__2 :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> IO CustomFunction
-customFunction__2 = casadi__CustomFunction__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__3" c_casadi__CustomFunction__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__3
-  :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__3 :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction
-customFunction__3 = casadi__CustomFunction__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__4" c_casadi__CustomFunction__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__4
-  :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__4 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> IO CustomFunction
-customFunction__4 = casadi__CustomFunction__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__5" c_casadi__CustomFunction__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__5
-  :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__5 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction
-customFunction__5 = casadi__CustomFunction__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__6" c_casadi__CustomFunction__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__6
-  :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__6 :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> IO CustomFunction
-customFunction__6 = casadi__CustomFunction__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__7" c_casadi__CustomFunction__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__7
-  :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__7 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__7 :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction
-customFunction__7 = casadi__CustomFunction__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__8" c_casadi__CustomFunction__CONSTRUCTOR__8
-  :: Ptr (Ptr StdString) -> IO (Ptr CustomFunction')
-casadi__CustomFunction__CONSTRUCTOR__8
-  :: IO CustomFunction
-casadi__CustomFunction__CONSTRUCTOR__8  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__CustomFunction__CONSTRUCTOR__8 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-customFunction__8 :: IO CustomFunction
-customFunction__8 = casadi__CustomFunction__CONSTRUCTOR__8
-
diff --git a/Casadi/Core/Classes/DM.hs b/Casadi/Core/Classes/DM.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/DM.hs
@@ -0,0 +1,5732 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.DM
+       (
+         DM,
+         DMClass(..),
+         dm_T,
+         dm__0,
+         dm__1,
+         dm__10,
+         dm__2,
+         dm__3,
+         dm__4,
+         dm__5,
+         dm__6,
+         dm__7,
+         dm__8,
+         dm__9,
+         dm___nonzero__,
+         dm_binary,
+         dm_clear,
+         dm_colind,
+         dm_dep__0,
+         dm_dep__1,
+         dm_dim,
+         dm_element_hash,
+         dm_enlarge__0,
+         dm_enlarge__1,
+         dm_erase__0,
+         dm_erase__1,
+         dm_erase__2,
+         dm_erase__3,
+         dm_eye,
+         dm_getDescription,
+         dm_getEqualityCheckingDepth,
+         dm_getRepresentation,
+         dm_get__0,
+         dm_get__1,
+         dm_get__2,
+         dm_get__3,
+         dm_get__4,
+         dm_get__5,
+         dm_get__6,
+         dm_get_colind,
+         dm_get_input,
+         dm_get_nonzeros,
+         dm_get_nz__0,
+         dm_get_nz__1,
+         dm_get_row,
+         dm_get_sparsity,
+         dm_grad__0,
+         dm_grad__1,
+         dm_grad__2,
+         dm_grad__3,
+         dm_grad__4,
+         dm_grad__5,
+         dm_grad__6,
+         dm_has_duplicates,
+         dm_has_nz,
+         dm_has_zeros,
+         dm_hess__0,
+         dm_hess__1,
+         dm_hess__2,
+         dm_hess__3,
+         dm_hess__4,
+         dm_hess__5,
+         dm_hess__6,
+         dm_inf__0,
+         dm_inf__1,
+         dm_inf__2,
+         dm_inf__3,
+         dm_inf__4,
+         dm_is_column,
+         dm_is_commutative,
+         dm_is_constant,
+         dm_is_dense,
+         dm_is_empty__0,
+         dm_is_empty__1,
+         dm_is_identity,
+         dm_is_integer,
+         dm_is_leaf,
+         dm_is_minus_one,
+         dm_is_one,
+         dm_is_regular,
+         dm_is_row,
+         dm_is_scalar__0,
+         dm_is_scalar__1,
+         dm_is_smooth,
+         dm_is_square,
+         dm_is_symbolic,
+         dm_is_tril,
+         dm_is_triu,
+         dm_is_valid_input,
+         dm_is_vector,
+         dm_is_zero,
+         dm_jac__0,
+         dm_jac__1,
+         dm_jac__10,
+         dm_jac__11,
+         dm_jac__12,
+         dm_jac__13,
+         dm_jac__14,
+         dm_jac__2,
+         dm_jac__3,
+         dm_jac__4,
+         dm_jac__5,
+         dm_jac__6,
+         dm_jac__7,
+         dm_jac__8,
+         dm_jac__9,
+         dm_matrix_matrix,
+         dm_matrix_scalar,
+         dm_n_dep,
+         dm_name,
+         dm_nan__0,
+         dm_nan__1,
+         dm_nan__2,
+         dm_nan__3,
+         dm_nan__4,
+         dm_nnz,
+         dm_nnz_diag,
+         dm_nnz_lower,
+         dm_nnz_upper,
+         dm_numel__0,
+         dm_numel__1,
+         dm_ones__0,
+         dm_ones__1,
+         dm_ones__2,
+         dm_ones__3,
+         dm_ones__4,
+         dm_operator__minus,
+         dm_operator__plus,
+         dm_operator_double,
+         dm_operator_int,
+         dm_print_dense,
+         dm_print_scalar,
+         dm_print_sparse,
+         dm_print_split,
+         dm_print_vector,
+         dm_printme,
+         dm_remove,
+         dm_reserve__0,
+         dm_reserve__1,
+         dm_resetInput,
+         dm_resize,
+         dm_row,
+         dm_sanity_check__0,
+         dm_sanity_check__1,
+         dm_scalar_matrix,
+         dm_setEqualityCheckingDepth__0,
+         dm_setEqualityCheckingDepth__1,
+         dm_setPrecision,
+         dm_setScientific,
+         dm_setWidth,
+         dm_set__0,
+         dm_set__1,
+         dm_set__2,
+         dm_set__3,
+         dm_set__4,
+         dm_set__5,
+         dm_set__6,
+         dm_set_nz__0,
+         dm_set_nz__1,
+         dm_size1,
+         dm_size2,
+         dm_size__0,
+         dm_size__1,
+         dm_sparsity,
+         dm_sym__0,
+         dm_sym__1,
+         dm_sym__2,
+         dm_sym__3,
+         dm_sym__4,
+         dm_sym__5,
+         dm_sym__6,
+         dm_sym__7,
+         dm_sym__8,
+         dm_tang__0,
+         dm_tang__1,
+         dm_tang__2,
+         dm_tang__3,
+         dm_tang__4,
+         dm_tang__5,
+         dm_tang__6,
+         dm_triplet__0,
+         dm_triplet__1,
+         dm_triplet__2,
+         dm_type_name,
+         dm_unary,
+         dm_zeros__0,
+         dm_zeros__1,
+         dm_zeros__2,
+         dm_zeros__3,
+         dm_zeros__4,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__0" c_casadi__DM__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SXElem')) -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__0
+  :: Vector SXElem -> IO DM
+casadi__DM__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__0 :: Vector SXElem -> IO DM
+dm__0 = casadi__DM__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__1" c_casadi__DM__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__1
+  :: SX -> IO DM
+casadi__DM__CONSTRUCTOR__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__1 :: SX -> IO DM
+dm__1 = casadi__DM__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__2" c_casadi__DM__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__2
+  :: Vector Int -> IO DM
+casadi__DM__CONSTRUCTOR__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__2 :: Vector Int -> IO DM
+dm__2 = casadi__DM__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__3" c_casadi__DM__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__3
+  :: IM -> IO DM
+casadi__DM__CONSTRUCTOR__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__3 :: IM -> IO DM
+dm__3 = casadi__DM__CONSTRUCTOR__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__4" c_casadi__DM__CONSTRUCTOR__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__4
+  :: Vector (Vector Double) -> IO DM
+casadi__DM__CONSTRUCTOR__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__4 :: Vector (Vector Double) -> IO DM
+dm__4 = casadi__DM__CONSTRUCTOR__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__5" c_casadi__DM__CONSTRUCTOR__5
+  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__5
+  :: Double -> IO DM
+casadi__DM__CONSTRUCTOR__5 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__5 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__5 :: Double -> IO DM
+dm__5 = casadi__DM__CONSTRUCTOR__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__6" c_casadi__DM__CONSTRUCTOR__6
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__6
+  :: Sparsity -> DM -> IO DM
+casadi__DM__CONSTRUCTOR__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__6 :: Sparsity -> DM -> IO DM
+dm__6 = casadi__DM__CONSTRUCTOR__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__7" c_casadi__DM__CONSTRUCTOR__7
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__7
+  :: Sparsity -> IO DM
+casadi__DM__CONSTRUCTOR__7 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__7 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__7 :: Sparsity -> IO DM
+dm__7 = casadi__DM__CONSTRUCTOR__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__8" c_casadi__DM__CONSTRUCTOR__8
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__8
+  :: Int -> Int -> IO DM
+casadi__DM__CONSTRUCTOR__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__8 :: Int -> Int -> IO DM
+dm__8 = casadi__DM__CONSTRUCTOR__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__9" c_casadi__DM__CONSTRUCTOR__9
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__9
+  :: DM -> IO DM
+casadi__DM__CONSTRUCTOR__9 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__9 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm__9 :: DM -> IO DM
+dm__9 = casadi__DM__CONSTRUCTOR__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__CONSTRUCTOR__10" c_casadi__DM__CONSTRUCTOR__10
+  :: Ptr (Ptr StdString) -> IO (Ptr DM')
+
+casadi__DM__CONSTRUCTOR__10
+  :: IO DM
+casadi__DM__CONSTRUCTOR__10  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__CONSTRUCTOR__10 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+dm__10 :: IO DM
+dm__10 = casadi__DM__CONSTRUCTOR__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__T" c_casadi__DM__T
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__T
+  :: DM -> IO DM
+casadi__DM__T x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__T errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_T :: DMClass a => a -> IO DM
+dm_T x = casadi__DM__T (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM____nonzero__" c_casadi__DM____nonzero__
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM____nonzero__
+  :: DM -> IO Bool
+casadi__DM____nonzero__ x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM____nonzero__ errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm___nonzero__ :: DMClass a => a -> IO Bool
+dm___nonzero__ x = casadi__DM____nonzero__ (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__binary" c_casadi__DM__binary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__binary
+  :: Int -> DM -> DM -> IO DM
+casadi__DM__binary x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__binary errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_binary :: Int -> DM -> DM -> IO DM
+dm_binary = casadi__DM__binary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__clear" c_casadi__DM__clear
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO ()
+
+casadi__DM__clear
+  :: DM -> IO ()
+casadi__DM__clear x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__clear errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_clear :: DMClass a => a -> IO ()
+dm_clear x = casadi__DM__clear (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__colind" c_casadi__DM__colind
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO CInt
+
+casadi__DM__colind
+  :: DM -> Int -> IO Int
+casadi__DM__colind x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__colind errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_colind :: DMClass a => a -> Int -> IO Int
+dm_colind x = casadi__DM__colind (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__dep__0" c_casadi__DM__dep__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__dep__0
+  :: DM -> IO DM
+casadi__DM__dep__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__dep__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_dep__0 :: DMClass a => a -> IO DM
+dm_dep__0 x = casadi__DM__dep__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__dep__1" c_casadi__DM__dep__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi__DM__dep__1
+  :: DM -> Int -> IO DM
+casadi__DM__dep__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__dep__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_dep__1 :: DMClass a => a -> Int -> IO DM
+dm_dep__1 x = casadi__DM__dep__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__dim" c_casadi__DM__dim
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr StdString)
+
+casadi__DM__dim
+  :: DM -> IO String
+casadi__DM__dim x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__dim errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_dim :: DMClass a => a -> IO String
+dm_dim x = casadi__DM__dim (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__element_hash" c_casadi__DM__element_hash
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CSize
+
+casadi__DM__element_hash
+  :: DM -> IO CSize
+casadi__DM__element_hash x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__element_hash errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_element_hash :: DMClass a => a -> IO CSize
+dm_element_hash x = casadi__DM__element_hash (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__enlarge__0" c_casadi__DM__enlarge__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__DM__enlarge__0
+  :: DM -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+casadi__DM__enlarge__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_enlarge__0 :: DMClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+dm_enlarge__0 x = casadi__DM__enlarge__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__enlarge__1" c_casadi__DM__enlarge__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__DM__enlarge__1
+  :: DM -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__DM__enlarge__1 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_enlarge__1 :: DMClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+dm_enlarge__1 x = casadi__DM__enlarge__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__erase__0" c_casadi__DM__erase__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> IO ()
+
+casadi__DM__erase__0
+  :: DM -> Vector Int -> IO ()
+casadi__DM__erase__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__erase__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_erase__0 :: DMClass a => a -> Vector Int -> IO ()
+dm_erase__0 x = casadi__DM__erase__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__erase__1" c_casadi__DM__erase__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__DM__erase__1
+  :: DM -> Vector Int -> Bool -> IO ()
+casadi__DM__erase__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__erase__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_erase__1 :: DMClass a => a -> Vector Int -> Bool -> IO ()
+dm_erase__1 x = casadi__DM__erase__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__erase__2" c_casadi__DM__erase__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__DM__erase__2
+  :: DM -> Vector Int -> Vector Int -> IO ()
+casadi__DM__erase__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__erase__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_erase__2 :: DMClass a => a -> Vector Int -> Vector Int -> IO ()
+dm_erase__2 x = casadi__DM__erase__2 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__erase__3" c_casadi__DM__erase__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__DM__erase__3
+  :: DM -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__DM__erase__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__erase__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_erase__3 :: DMClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
+dm_erase__3 x = casadi__DM__erase__3 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__eye" c_casadi__DM__eye
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DM')
+
+casadi__DM__eye
+  :: Int -> IO DM
+casadi__DM__eye x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__eye errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_eye :: Int -> IO DM
+dm_eye = casadi__DM__eye
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get__0" c_casadi__DM__get__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__DM__get__0
+  :: DM -> Bool -> IM -> IM -> IO (DM)
+casadi__DM__get__0 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get__0 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get__0/c_casadi__DM__get__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get__0 :: DMClass a => a -> Bool -> IM -> IM -> IO (DM)
+dm_get__0 x = casadi__DM__get__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get__1" c_casadi__DM__get__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__DM__get__1
+  :: DM -> Bool -> IM -> Slice -> IO (DM)
+casadi__DM__get__1 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get__1 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get__1/c_casadi__DM__get__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get__1 :: DMClass a => a -> Bool -> IM -> Slice -> IO (DM)
+dm_get__1 x = casadi__DM__get__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get__2" c_casadi__DM__get__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__DM__get__2
+  :: DM -> Bool -> Slice -> IM -> IO (DM)
+casadi__DM__get__2 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get__2 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get__2/c_casadi__DM__get__2" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get__2 :: DMClass a => a -> Bool -> Slice -> IM -> IO (DM)
+dm_get__2 x = casadi__DM__get__2 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get__3" c_casadi__DM__get__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__DM__get__3
+  :: DM -> Bool -> Slice -> Slice -> IO (DM)
+casadi__DM__get__3 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get__3 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get__3/c_casadi__DM__get__3" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get__3 :: DMClass a => a -> Bool -> Slice -> Slice -> IO (DM)
+dm_get__3 x = casadi__DM__get__3 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get__4" c_casadi__DM__get__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__DM__get__4
+  :: DM -> Bool -> Sparsity -> IO (DM)
+casadi__DM__get__4 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get__4 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get__4/c_casadi__DM__get__4" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get__4 :: DMClass a => a -> Bool -> Sparsity -> IO (DM)
+dm_get__4 x = casadi__DM__get__4 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get__5" c_casadi__DM__get__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr IM' -> IO ()
+
+casadi__DM__get__5
+  :: DM -> Bool -> IM -> IO (DM)
+casadi__DM__get__5 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get__5 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get__5/c_casadi__DM__get__5" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get__5 :: DMClass a => a -> Bool -> IM -> IO (DM)
+dm_get__5 x = casadi__DM__get__5 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get__6" c_casadi__DM__get__6
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__DM__get__6
+  :: DM -> Bool -> Slice -> IO (DM)
+casadi__DM__get__6 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get__6 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get__6/c_casadi__DM__get__6" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get__6 :: DMClass a => a -> Bool -> Slice -> IO (DM)
+dm_get__6 x = casadi__DM__get__6 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__getEqualityCheckingDepth" c_casadi__DM__getEqualityCheckingDepth
+  :: Ptr (Ptr StdString) -> IO CInt
+
+casadi__DM__getEqualityCheckingDepth
+  :: IO Int
+casadi__DM__getEqualityCheckingDepth  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__getEqualityCheckingDepth errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+dm_getEqualityCheckingDepth :: IO Int
+dm_getEqualityCheckingDepth = casadi__DM__getEqualityCheckingDepth
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get_colind" c_casadi__DM__get_colind
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec CInt))
+
+casadi__DM__get_colind
+  :: DM -> IO (Vector Int)
+casadi__DM__get_colind x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get_colind errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_get_colind :: DMClass a => a -> IO (Vector Int)
+dm_get_colind x = casadi__DM__get_colind (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get_input" c_casadi__DM__get_input
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi__DM__get_input
+  :: Function -> IO (Vector DM)
+casadi__DM__get_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_get_input :: Function -> IO (Vector DM)
+dm_get_input = casadi__DM__get_input
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get_nonzeros" c_casadi__DM__get_nonzeros
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec CDouble))
+
+casadi__DM__get_nonzeros
+  :: DM -> IO (Vector Double)
+casadi__DM__get_nonzeros x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get_nonzeros errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_get_nonzeros :: DMClass a => a -> IO (Vector Double)
+dm_get_nonzeros x = casadi__DM__get_nonzeros (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get_nz__0" c_casadi__DM__get_nz__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr IM' -> IO ()
+
+casadi__DM__get_nz__0
+  :: DM -> Bool -> IM -> IO (DM)
+casadi__DM__get_nz__0 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get_nz__0 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get_nz__0/c_casadi__DM__get_nz__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get_nz__0 :: DMClass a => a -> Bool -> IM -> IO (DM)
+dm_get_nz__0 x = casadi__DM__get_nz__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get_nz__1" c_casadi__DM__get_nz__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr DM') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__DM__get_nz__1
+  :: DM -> Bool -> Slice -> IO (DM)
+casadi__DM__get_nz__1 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get_nz__1 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__get_nz__1/c_casadi__DM__get_nz__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+dm_get_nz__1 :: DMClass a => a -> Bool -> Slice -> IO (DM)
+dm_get_nz__1 x = casadi__DM__get_nz__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get_row" c_casadi__DM__get_row
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec CInt))
+
+casadi__DM__get_row
+  :: DM -> IO (Vector Int)
+casadi__DM__get_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_get_row :: DMClass a => a -> IO (Vector Int)
+dm_get_row x = casadi__DM__get_row (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__get_sparsity" c_casadi__DM__get_sparsity
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr Sparsity')
+
+casadi__DM__get_sparsity
+  :: DM -> IO Sparsity
+casadi__DM__get_sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__get_sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_get_sparsity :: DMClass a => a -> IO Sparsity
+dm_get_sparsity x = casadi__DM__get_sparsity (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__grad__0" c_casadi__DM__grad__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__grad__0
+  :: Function -> String -> String -> IO DM
+casadi__DM__grad__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__grad__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_grad__0 :: Function -> String -> String -> IO DM
+dm_grad__0 = casadi__DM__grad__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__grad__1" c_casadi__DM__grad__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__grad__1
+  :: Function -> Int -> String -> IO DM
+casadi__DM__grad__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__grad__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_grad__1 :: Function -> Int -> String -> IO DM
+dm_grad__1 = casadi__DM__grad__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__grad__2" c_casadi__DM__grad__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__grad__2
+  :: Function -> String -> IO DM
+casadi__DM__grad__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__grad__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_grad__2 :: Function -> String -> IO DM
+dm_grad__2 = casadi__DM__grad__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__grad__3" c_casadi__DM__grad__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr DM')
+
+casadi__DM__grad__3
+  :: Function -> String -> Int -> IO DM
+casadi__DM__grad__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__grad__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_grad__3 :: Function -> String -> Int -> IO DM
+dm_grad__3 = casadi__DM__grad__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__grad__4" c_casadi__DM__grad__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr DM')
+
+casadi__DM__grad__4
+  :: Function -> IO DM
+casadi__DM__grad__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__grad__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_grad__4 :: Function -> IO DM
+dm_grad__4 = casadi__DM__grad__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__grad__5" c_casadi__DM__grad__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr DM')
+
+casadi__DM__grad__5
+  :: Function -> Int -> IO DM
+casadi__DM__grad__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__grad__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_grad__5 :: Function -> Int -> IO DM
+dm_grad__5 = casadi__DM__grad__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__grad__6" c_casadi__DM__grad__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__grad__6
+  :: Function -> Int -> Int -> IO DM
+casadi__DM__grad__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__grad__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_grad__6 :: Function -> Int -> Int -> IO DM
+dm_grad__6 = casadi__DM__grad__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__has_duplicates" c_casadi__DM__has_duplicates
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__has_duplicates
+  :: DM -> IO Bool
+casadi__DM__has_duplicates x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__has_duplicates errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_has_duplicates :: DMClass a => a -> IO Bool
+dm_has_duplicates x = casadi__DM__has_duplicates (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__has_nz" c_casadi__DM__has_nz
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO CInt
+
+casadi__DM__has_nz
+  :: DM -> Int -> Int -> IO Bool
+casadi__DM__has_nz x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__has_nz errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_has_nz :: DMClass a => a -> Int -> Int -> IO Bool
+dm_has_nz x = casadi__DM__has_nz (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__has_zeros" c_casadi__DM__has_zeros
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__has_zeros
+  :: DM -> IO Bool
+casadi__DM__has_zeros x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__has_zeros errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_has_zeros :: DMClass a => a -> IO Bool
+dm_has_zeros x = casadi__DM__has_zeros (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__hess__0" c_casadi__DM__hess__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__hess__0
+  :: Function -> String -> String -> IO DM
+casadi__DM__hess__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__hess__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_hess__0 :: Function -> String -> String -> IO DM
+dm_hess__0 = casadi__DM__hess__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__hess__1" c_casadi__DM__hess__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__hess__1
+  :: Function -> Int -> String -> IO DM
+casadi__DM__hess__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__hess__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_hess__1 :: Function -> Int -> String -> IO DM
+dm_hess__1 = casadi__DM__hess__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__hess__2" c_casadi__DM__hess__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__hess__2
+  :: Function -> String -> IO DM
+casadi__DM__hess__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__hess__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_hess__2 :: Function -> String -> IO DM
+dm_hess__2 = casadi__DM__hess__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__hess__3" c_casadi__DM__hess__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr DM')
+
+casadi__DM__hess__3
+  :: Function -> String -> Int -> IO DM
+casadi__DM__hess__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__hess__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_hess__3 :: Function -> String -> Int -> IO DM
+dm_hess__3 = casadi__DM__hess__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__hess__4" c_casadi__DM__hess__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr DM')
+
+casadi__DM__hess__4
+  :: Function -> IO DM
+casadi__DM__hess__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__hess__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_hess__4 :: Function -> IO DM
+dm_hess__4 = casadi__DM__hess__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__hess__5" c_casadi__DM__hess__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr DM')
+
+casadi__DM__hess__5
+  :: Function -> Int -> IO DM
+casadi__DM__hess__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__hess__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_hess__5 :: Function -> Int -> IO DM
+dm_hess__5 = casadi__DM__hess__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__hess__6" c_casadi__DM__hess__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__hess__6
+  :: Function -> Int -> Int -> IO DM
+casadi__DM__hess__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__hess__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_hess__6 :: Function -> Int -> Int -> IO DM
+dm_hess__6 = casadi__DM__hess__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__inf__0" c_casadi__DM__inf__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi__DM__inf__0
+  :: (Int, Int) -> IO DM
+casadi__DM__inf__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__inf__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_inf__0 :: (Int, Int) -> IO DM
+dm_inf__0 = casadi__DM__inf__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__inf__1" c_casadi__DM__inf__1
+  :: Ptr (Ptr StdString) -> IO (Ptr DM')
+
+casadi__DM__inf__1
+  :: IO DM
+casadi__DM__inf__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__inf__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+dm_inf__1 :: IO DM
+dm_inf__1 = casadi__DM__inf__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__inf__2" c_casadi__DM__inf__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DM')
+
+casadi__DM__inf__2
+  :: Int -> IO DM
+casadi__DM__inf__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__inf__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_inf__2 :: Int -> IO DM
+dm_inf__2 = casadi__DM__inf__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__inf__3" c_casadi__DM__inf__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__inf__3
+  :: Int -> Int -> IO DM
+casadi__DM__inf__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__inf__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_inf__3 :: Int -> Int -> IO DM
+dm_inf__3 = casadi__DM__inf__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__inf__4" c_casadi__DM__inf__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi__DM__inf__4
+  :: Sparsity -> IO DM
+casadi__DM__inf__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__inf__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_inf__4 :: Sparsity -> IO DM
+dm_inf__4 = casadi__DM__inf__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_column" c_casadi__DM__is_column
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_column
+  :: DM -> IO Bool
+casadi__DM__is_column x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_column errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_column :: DMClass a => a -> IO Bool
+dm_is_column x = casadi__DM__is_column (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_commutative" c_casadi__DM__is_commutative
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_commutative
+  :: DM -> IO Bool
+casadi__DM__is_commutative x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_commutative errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_commutative :: DMClass a => a -> IO Bool
+dm_is_commutative x = casadi__DM__is_commutative (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_constant" c_casadi__DM__is_constant
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_constant
+  :: DM -> IO Bool
+casadi__DM__is_constant x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_constant errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_constant :: DMClass a => a -> IO Bool
+dm_is_constant x = casadi__DM__is_constant (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_dense" c_casadi__DM__is_dense
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_dense
+  :: DM -> IO Bool
+casadi__DM__is_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_dense :: DMClass a => a -> IO Bool
+dm_is_dense x = casadi__DM__is_dense (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_empty__0" c_casadi__DM__is_empty__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_empty__0
+  :: DM -> IO Bool
+casadi__DM__is_empty__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_empty__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_empty__0 :: DMClass a => a -> IO Bool
+dm_is_empty__0 x = casadi__DM__is_empty__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_empty__1" c_casadi__DM__is_empty__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO CInt
+
+casadi__DM__is_empty__1
+  :: DM -> Bool -> IO Bool
+casadi__DM__is_empty__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_empty__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_empty__1 :: DMClass a => a -> Bool -> IO Bool
+dm_is_empty__1 x = casadi__DM__is_empty__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_identity" c_casadi__DM__is_identity
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_identity
+  :: DM -> IO Bool
+casadi__DM__is_identity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_identity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_identity :: DMClass a => a -> IO Bool
+dm_is_identity x = casadi__DM__is_identity (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_integer" c_casadi__DM__is_integer
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_integer
+  :: DM -> IO Bool
+casadi__DM__is_integer x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_integer errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_integer :: DMClass a => a -> IO Bool
+dm_is_integer x = casadi__DM__is_integer (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_leaf" c_casadi__DM__is_leaf
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_leaf
+  :: DM -> IO Bool
+casadi__DM__is_leaf x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_leaf errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_leaf :: DMClass a => a -> IO Bool
+dm_is_leaf x = casadi__DM__is_leaf (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_minus_one" c_casadi__DM__is_minus_one
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_minus_one
+  :: DM -> IO Bool
+casadi__DM__is_minus_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_minus_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_minus_one :: DMClass a => a -> IO Bool
+dm_is_minus_one x = casadi__DM__is_minus_one (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_one" c_casadi__DM__is_one
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_one
+  :: DM -> IO Bool
+casadi__DM__is_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_one :: DMClass a => a -> IO Bool
+dm_is_one x = casadi__DM__is_one (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_regular" c_casadi__DM__is_regular
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_regular
+  :: DM -> IO Bool
+casadi__DM__is_regular x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_regular errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_regular :: DMClass a => a -> IO Bool
+dm_is_regular x = casadi__DM__is_regular (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_row" c_casadi__DM__is_row
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_row
+  :: DM -> IO Bool
+casadi__DM__is_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_row :: DMClass a => a -> IO Bool
+dm_is_row x = casadi__DM__is_row (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_scalar__0" c_casadi__DM__is_scalar__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_scalar__0
+  :: DM -> IO Bool
+casadi__DM__is_scalar__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_scalar__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_scalar__0 :: DMClass a => a -> IO Bool
+dm_is_scalar__0 x = casadi__DM__is_scalar__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_scalar__1" c_casadi__DM__is_scalar__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO CInt
+
+casadi__DM__is_scalar__1
+  :: DM -> Bool -> IO Bool
+casadi__DM__is_scalar__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_scalar__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_scalar__1 :: DMClass a => a -> Bool -> IO Bool
+dm_is_scalar__1 x = casadi__DM__is_scalar__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_smooth" c_casadi__DM__is_smooth
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_smooth
+  :: DM -> IO Bool
+casadi__DM__is_smooth x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_smooth errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_smooth :: DMClass a => a -> IO Bool
+dm_is_smooth x = casadi__DM__is_smooth (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_square" c_casadi__DM__is_square
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_square
+  :: DM -> IO Bool
+casadi__DM__is_square x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_square errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_square :: DMClass a => a -> IO Bool
+dm_is_square x = casadi__DM__is_square (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_symbolic" c_casadi__DM__is_symbolic
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_symbolic
+  :: DM -> IO Bool
+casadi__DM__is_symbolic x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_symbolic errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_symbolic :: DMClass a => a -> IO Bool
+dm_is_symbolic x = casadi__DM__is_symbolic (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_tril" c_casadi__DM__is_tril
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_tril
+  :: DM -> IO Bool
+casadi__DM__is_tril x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_tril errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_tril :: DMClass a => a -> IO Bool
+dm_is_tril x = casadi__DM__is_tril (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_triu" c_casadi__DM__is_triu
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_triu
+  :: DM -> IO Bool
+casadi__DM__is_triu x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_triu errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_triu :: DMClass a => a -> IO Bool
+dm_is_triu x = casadi__DM__is_triu (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_valid_input" c_casadi__DM__is_valid_input
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_valid_input
+  :: DM -> IO Bool
+casadi__DM__is_valid_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_valid_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_valid_input :: DMClass a => a -> IO Bool
+dm_is_valid_input x = casadi__DM__is_valid_input (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_vector" c_casadi__DM__is_vector
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_vector
+  :: DM -> IO Bool
+casadi__DM__is_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_vector :: DMClass a => a -> IO Bool
+dm_is_vector x = casadi__DM__is_vector (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__is_zero" c_casadi__DM__is_zero
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__is_zero
+  :: DM -> IO Bool
+casadi__DM__is_zero x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__is_zero errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_is_zero :: DMClass a => a -> IO Bool
+dm_is_zero x = casadi__DM__is_zero (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__0" c_casadi__DM__jac__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__jac__0
+  :: Function -> String -> String -> IO DM
+casadi__DM__jac__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__0 :: Function -> String -> String -> IO DM
+dm_jac__0 = casadi__DM__jac__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__1" c_casadi__DM__jac__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__1
+  :: Function -> String -> String -> Bool -> IO DM
+casadi__DM__jac__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__1 :: Function -> String -> String -> Bool -> IO DM
+dm_jac__1 = casadi__DM__jac__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__2" c_casadi__DM__jac__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__2
+  :: Function -> String -> String -> Bool -> Bool -> IO DM
+casadi__DM__jac__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__2 :: Function -> String -> String -> Bool -> Bool -> IO DM
+dm_jac__2 = casadi__DM__jac__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__3" c_casadi__DM__jac__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__jac__3
+  :: Function -> Int -> String -> IO DM
+casadi__DM__jac__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__3 :: Function -> Int -> String -> IO DM
+dm_jac__3 = casadi__DM__jac__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__4" c_casadi__DM__jac__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__4
+  :: Function -> Int -> String -> Bool -> IO DM
+casadi__DM__jac__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__4 :: Function -> Int -> String -> Bool -> IO DM
+dm_jac__4 = casadi__DM__jac__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__5" c_casadi__DM__jac__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__5
+  :: Function -> Int -> String -> Bool -> Bool -> IO DM
+casadi__DM__jac__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__5 :: Function -> Int -> String -> Bool -> Bool -> IO DM
+dm_jac__5 = casadi__DM__jac__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__6" c_casadi__DM__jac__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__jac__6
+  :: Function -> String -> IO DM
+casadi__DM__jac__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__6 :: Function -> String -> IO DM
+dm_jac__6 = casadi__DM__jac__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__7" c_casadi__DM__jac__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__7
+  :: Function -> String -> Int -> IO DM
+casadi__DM__jac__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__7 :: Function -> String -> Int -> IO DM
+dm_jac__7 = casadi__DM__jac__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__8" c_casadi__DM__jac__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__8
+  :: Function -> String -> Int -> Bool -> IO DM
+casadi__DM__jac__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__8 :: Function -> String -> Int -> Bool -> IO DM
+dm_jac__8 = casadi__DM__jac__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__9" c_casadi__DM__jac__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__9
+  :: Function -> String -> Int -> Bool -> Bool -> IO DM
+casadi__DM__jac__9 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__9 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__9 :: Function -> String -> Int -> Bool -> Bool -> IO DM
+dm_jac__9 = casadi__DM__jac__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__10" c_casadi__DM__jac__10
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr DM')
+
+casadi__DM__jac__10
+  :: Function -> IO DM
+casadi__DM__jac__10 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__10 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__10 :: Function -> IO DM
+dm_jac__10 = casadi__DM__jac__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__11" c_casadi__DM__jac__11
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__11
+  :: Function -> Int -> IO DM
+casadi__DM__jac__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__11 :: Function -> Int -> IO DM
+dm_jac__11 = casadi__DM__jac__11
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__12" c_casadi__DM__jac__12
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__12
+  :: Function -> Int -> Int -> IO DM
+casadi__DM__jac__12 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__12 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__12 :: Function -> Int -> Int -> IO DM
+dm_jac__12 = casadi__DM__jac__12
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__13" c_casadi__DM__jac__13
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__13
+  :: Function -> Int -> Int -> Bool -> IO DM
+casadi__DM__jac__13 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__13 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__13 :: Function -> Int -> Int -> Bool -> IO DM
+dm_jac__13 = casadi__DM__jac__13
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__jac__14" c_casadi__DM__jac__14
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__jac__14
+  :: Function -> Int -> Int -> Bool -> Bool -> IO DM
+casadi__DM__jac__14 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__jac__14 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_jac__14 :: Function -> Int -> Int -> Bool -> Bool -> IO DM
+dm_jac__14 = casadi__DM__jac__14
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__matrix_matrix" c_casadi__DM__matrix_matrix
+  :: Ptr (Ptr StdString) -> CInt -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__matrix_matrix
+  :: Int -> DM -> DM -> IO DM
+casadi__DM__matrix_matrix x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__matrix_matrix errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_matrix_matrix :: Int -> DM -> DM -> IO DM
+dm_matrix_matrix = casadi__DM__matrix_matrix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__matrix_scalar" c_casadi__DM__matrix_scalar
+  :: Ptr (Ptr StdString) -> CInt -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__matrix_scalar
+  :: Int -> DM -> DM -> IO DM
+casadi__DM__matrix_scalar x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__matrix_scalar errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_matrix_scalar :: Int -> DM -> DM -> IO DM
+dm_matrix_scalar = casadi__DM__matrix_scalar
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__n_dep" c_casadi__DM__n_dep
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__n_dep
+  :: DM -> IO Int
+casadi__DM__n_dep x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__n_dep errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_n_dep :: DMClass a => a -> IO Int
+dm_n_dep x = casadi__DM__n_dep (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__name" c_casadi__DM__name
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr StdString)
+
+casadi__DM__name
+  :: DM -> IO String
+casadi__DM__name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_name :: DMClass a => a -> IO String
+dm_name x = casadi__DM__name (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nan__0" c_casadi__DM__nan__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi__DM__nan__0
+  :: (Int, Int) -> IO DM
+casadi__DM__nan__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nan__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nan__0 :: (Int, Int) -> IO DM
+dm_nan__0 = casadi__DM__nan__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nan__1" c_casadi__DM__nan__1
+  :: Ptr (Ptr StdString) -> IO (Ptr DM')
+
+casadi__DM__nan__1
+  :: IO DM
+casadi__DM__nan__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nan__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nan__1 :: IO DM
+dm_nan__1 = casadi__DM__nan__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nan__2" c_casadi__DM__nan__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DM')
+
+casadi__DM__nan__2
+  :: Int -> IO DM
+casadi__DM__nan__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nan__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nan__2 :: Int -> IO DM
+dm_nan__2 = casadi__DM__nan__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nan__3" c_casadi__DM__nan__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__nan__3
+  :: Int -> Int -> IO DM
+casadi__DM__nan__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nan__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nan__3 :: Int -> Int -> IO DM
+dm_nan__3 = casadi__DM__nan__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nan__4" c_casadi__DM__nan__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi__DM__nan__4
+  :: Sparsity -> IO DM
+casadi__DM__nan__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nan__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nan__4 :: Sparsity -> IO DM
+dm_nan__4 = casadi__DM__nan__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nnz" c_casadi__DM__nnz
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__nnz
+  :: DM -> IO Int
+casadi__DM__nnz x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nnz errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nnz :: DMClass a => a -> IO Int
+dm_nnz x = casadi__DM__nnz (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nnz_diag" c_casadi__DM__nnz_diag
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__nnz_diag
+  :: DM -> IO Int
+casadi__DM__nnz_diag x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nnz_diag errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nnz_diag :: DMClass a => a -> IO Int
+dm_nnz_diag x = casadi__DM__nnz_diag (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nnz_lower" c_casadi__DM__nnz_lower
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__nnz_lower
+  :: DM -> IO Int
+casadi__DM__nnz_lower x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nnz_lower errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nnz_lower :: DMClass a => a -> IO Int
+dm_nnz_lower x = casadi__DM__nnz_lower (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__nnz_upper" c_casadi__DM__nnz_upper
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__nnz_upper
+  :: DM -> IO Int
+casadi__DM__nnz_upper x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__nnz_upper errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_nnz_upper :: DMClass a => a -> IO Int
+dm_nnz_upper x = casadi__DM__nnz_upper (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__numel__0" c_casadi__DM__numel__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO CInt
+
+casadi__DM__numel__0
+  :: DM -> Int -> IO Int
+casadi__DM__numel__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__numel__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_numel__0 :: DMClass a => a -> Int -> IO Int
+dm_numel__0 x = casadi__DM__numel__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__numel__1" c_casadi__DM__numel__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__numel__1
+  :: DM -> IO Int
+casadi__DM__numel__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__numel__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_numel__1 :: DMClass a => a -> IO Int
+dm_numel__1 x = casadi__DM__numel__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__ones__0" c_casadi__DM__ones__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi__DM__ones__0
+  :: (Int, Int) -> IO DM
+casadi__DM__ones__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__ones__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_ones__0 :: (Int, Int) -> IO DM
+dm_ones__0 = casadi__DM__ones__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__ones__1" c_casadi__DM__ones__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi__DM__ones__1
+  :: Sparsity -> IO DM
+casadi__DM__ones__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__ones__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_ones__1 :: Sparsity -> IO DM
+dm_ones__1 = casadi__DM__ones__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__ones__2" c_casadi__DM__ones__2
+  :: Ptr (Ptr StdString) -> IO (Ptr DM')
+
+casadi__DM__ones__2
+  :: IO DM
+casadi__DM__ones__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__ones__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+dm_ones__2 :: IO DM
+dm_ones__2 = casadi__DM__ones__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__ones__3" c_casadi__DM__ones__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DM')
+
+casadi__DM__ones__3
+  :: Int -> IO DM
+casadi__DM__ones__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__ones__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_ones__3 :: Int -> IO DM
+dm_ones__3 = casadi__DM__ones__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__ones__4" c_casadi__DM__ones__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__ones__4
+  :: Int -> Int -> IO DM
+casadi__DM__ones__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__ones__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_ones__4 :: Int -> Int -> IO DM
+dm_ones__4 = casadi__DM__ones__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__operator__plus" c_casadi__DM__operator__plus
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__operator__plus
+  :: DM -> IO DM
+casadi__DM__operator__plus x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__operator__plus errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_operator__plus :: DMClass a => a -> IO DM
+dm_operator__plus x = casadi__DM__operator__plus (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__operator__minus" c_casadi__DM__operator__minus
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__operator__minus
+  :: DM -> IO DM
+casadi__DM__operator__minus x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__operator__minus errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_operator__minus :: DMClass a => a -> IO DM
+dm_operator__minus x = casadi__DM__operator__minus (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__operator_double" c_casadi__DM__operator_double
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CDouble
+
+casadi__DM__operator_double
+  :: DM -> IO Double
+casadi__DM__operator_double x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__operator_double errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_operator_double :: DMClass a => a -> IO Double
+dm_operator_double x = casadi__DM__operator_double (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__operator_int" c_casadi__DM__operator_int
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__operator_int
+  :: DM -> IO Int
+casadi__DM__operator_int x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__operator_int errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_operator_int :: DMClass a => a -> IO Int
+dm_operator_int x = casadi__DM__operator_int (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__print_dense" c_casadi__DM__print_dense
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO ()
+
+casadi__DM__print_dense
+  :: DM -> IO ()
+casadi__DM__print_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__print_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_print_dense :: DMClass a => a -> IO ()
+dm_print_dense x = casadi__DM__print_dense (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__print_scalar" c_casadi__DM__print_scalar
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO ()
+
+casadi__DM__print_scalar
+  :: DM -> IO ()
+casadi__DM__print_scalar x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__print_scalar errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_print_scalar :: DMClass a => a -> IO ()
+dm_print_scalar x = casadi__DM__print_scalar (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__print_sparse" c_casadi__DM__print_sparse
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO ()
+
+casadi__DM__print_sparse
+  :: DM -> IO ()
+casadi__DM__print_sparse x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__print_sparse errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_print_sparse :: DMClass a => a -> IO ()
+dm_print_sparse x = casadi__DM__print_sparse (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__print_split" c_casadi__DM__print_split
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (Ptr (StdVec (Ptr StdString))) -> Ptr (Ptr (StdVec (Ptr StdString))) -> IO ()
+
+casadi__DM__print_split
+  :: DM -> IO (Vector String, Vector String)
+casadi__DM__print_split x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__print_split errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__DM__print_split/c_casadi__DM__print_split" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__DM__print_split/c_casadi__DM__print_split" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+-- classy wrapper
+dm_print_split :: DMClass a => a -> IO (Vector String, Vector String)
+dm_print_split x = casadi__DM__print_split (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__print_vector" c_casadi__DM__print_vector
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO ()
+
+casadi__DM__print_vector
+  :: DM -> IO ()
+casadi__DM__print_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__print_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_print_vector :: DMClass a => a -> IO ()
+dm_print_vector x = casadi__DM__print_vector (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__printme" c_casadi__DM__printme
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__printme
+  :: DM -> DM -> IO DM
+casadi__DM__printme x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__printme errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_printme :: DMClass a => a -> DM -> IO DM
+dm_printme x = casadi__DM__printme (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__remove" c_casadi__DM__remove
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__DM__remove
+  :: DM -> Vector Int -> Vector Int -> IO ()
+casadi__DM__remove x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__remove errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_remove :: DMClass a => a -> Vector Int -> Vector Int -> IO ()
+dm_remove x = casadi__DM__remove (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__reserve__0" c_casadi__DM__reserve__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO ()
+
+casadi__DM__reserve__0
+  :: DM -> Int -> Int -> IO ()
+casadi__DM__reserve__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__reserve__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_reserve__0 :: DMClass a => a -> Int -> Int -> IO ()
+dm_reserve__0 x = casadi__DM__reserve__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__reserve__1" c_casadi__DM__reserve__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO ()
+
+casadi__DM__reserve__1
+  :: DM -> Int -> IO ()
+casadi__DM__reserve__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__reserve__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_reserve__1 :: DMClass a => a -> Int -> IO ()
+dm_reserve__1 x = casadi__DM__reserve__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__resetInput" c_casadi__DM__resetInput
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO ()
+
+casadi__DM__resetInput
+  :: DM -> IO ()
+casadi__DM__resetInput x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__resetInput errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_resetInput :: DMClass a => a -> IO ()
+dm_resetInput x = casadi__DM__resetInput (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__resize" c_casadi__DM__resize
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO ()
+
+casadi__DM__resize
+  :: DM -> Int -> Int -> IO ()
+casadi__DM__resize x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__resize errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_resize :: DMClass a => a -> Int -> Int -> IO ()
+dm_resize x = casadi__DM__resize (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__row" c_casadi__DM__row
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO CInt
+
+casadi__DM__row
+  :: DM -> Int -> IO Int
+casadi__DM__row x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__row errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_row :: DMClass a => a -> Int -> IO Int
+dm_row x = casadi__DM__row (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sanity_check__0" c_casadi__DM__sanity_check__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO ()
+
+casadi__DM__sanity_check__0
+  :: DM -> IO ()
+casadi__DM__sanity_check__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sanity_check__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_sanity_check__0 :: DMClass a => a -> IO ()
+dm_sanity_check__0 x = casadi__DM__sanity_check__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sanity_check__1" c_casadi__DM__sanity_check__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO ()
+
+casadi__DM__sanity_check__1
+  :: DM -> Bool -> IO ()
+casadi__DM__sanity_check__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sanity_check__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_sanity_check__1 :: DMClass a => a -> Bool -> IO ()
+dm_sanity_check__1 x = casadi__DM__sanity_check__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__scalar_matrix" c_casadi__DM__scalar_matrix
+  :: Ptr (Ptr StdString) -> CInt -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__scalar_matrix
+  :: Int -> DM -> DM -> IO DM
+casadi__DM__scalar_matrix x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__scalar_matrix errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_scalar_matrix :: Int -> DM -> DM -> IO DM
+dm_scalar_matrix = casadi__DM__scalar_matrix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set__0" c_casadi__DM__set__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__DM__set__0
+  :: DM -> DM -> Bool -> IM -> IM -> IO ()
+casadi__DM__set__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set__0 :: DMClass a => a -> DM -> Bool -> IM -> IM -> IO ()
+dm_set__0 x = casadi__DM__set__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set__1" c_casadi__DM__set__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__DM__set__1
+  :: DM -> DM -> Bool -> IM -> Slice -> IO ()
+casadi__DM__set__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set__1 :: DMClass a => a -> DM -> Bool -> IM -> Slice -> IO ()
+dm_set__1 x = casadi__DM__set__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set__2" c_casadi__DM__set__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__DM__set__2
+  :: DM -> DM -> Bool -> Slice -> IM -> IO ()
+casadi__DM__set__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set__2 :: DMClass a => a -> DM -> Bool -> Slice -> IM -> IO ()
+dm_set__2 x = casadi__DM__set__2 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set__3" c_casadi__DM__set__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__DM__set__3
+  :: DM -> DM -> Bool -> Slice -> Slice -> IO ()
+casadi__DM__set__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set__3 :: DMClass a => a -> DM -> Bool -> Slice -> Slice -> IO ()
+dm_set__3 x = casadi__DM__set__3 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set__4" c_casadi__DM__set__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__DM__set__4
+  :: DM -> DM -> Bool -> Sparsity -> IO ()
+casadi__DM__set__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set__4 :: DMClass a => a -> DM -> Bool -> Sparsity -> IO ()
+dm_set__4 x = casadi__DM__set__4 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set__5" c_casadi__DM__set__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr IM' -> IO ()
+
+casadi__DM__set__5
+  :: DM -> DM -> Bool -> IM -> IO ()
+casadi__DM__set__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set__5 :: DMClass a => a -> DM -> Bool -> IM -> IO ()
+dm_set__5 x = casadi__DM__set__5 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set__6" c_casadi__DM__set__6
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__DM__set__6
+  :: DM -> DM -> Bool -> Slice -> IO ()
+casadi__DM__set__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set__6 :: DMClass a => a -> DM -> Bool -> Slice -> IO ()
+dm_set__6 x = casadi__DM__set__6 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__setEqualityCheckingDepth__0" c_casadi__DM__setEqualityCheckingDepth__0
+  :: Ptr (Ptr StdString) -> IO ()
+
+casadi__DM__setEqualityCheckingDepth__0
+  :: IO ()
+casadi__DM__setEqualityCheckingDepth__0  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__setEqualityCheckingDepth__0 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ()
+
+
+
+-- classy wrapper
+dm_setEqualityCheckingDepth__0 :: IO ()
+dm_setEqualityCheckingDepth__0 = casadi__DM__setEqualityCheckingDepth__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__setEqualityCheckingDepth__1" c_casadi__DM__setEqualityCheckingDepth__1
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__DM__setEqualityCheckingDepth__1
+  :: Int -> IO ()
+casadi__DM__setEqualityCheckingDepth__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__setEqualityCheckingDepth__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_setEqualityCheckingDepth__1 :: Int -> IO ()
+dm_setEqualityCheckingDepth__1 = casadi__DM__setEqualityCheckingDepth__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__setPrecision" c_casadi__DM__setPrecision
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__DM__setPrecision
+  :: Int -> IO ()
+casadi__DM__setPrecision x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__setPrecision errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_setPrecision :: Int -> IO ()
+dm_setPrecision = casadi__DM__setPrecision
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__setScientific" c_casadi__DM__setScientific
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__DM__setScientific
+  :: Bool -> IO ()
+casadi__DM__setScientific x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__setScientific errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_setScientific :: Bool -> IO ()
+dm_setScientific = casadi__DM__setScientific
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__setWidth" c_casadi__DM__setWidth
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__DM__setWidth
+  :: Int -> IO ()
+casadi__DM__setWidth x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__setWidth errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_setWidth :: Int -> IO ()
+dm_setWidth = casadi__DM__setWidth
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set_nz__0" c_casadi__DM__set_nz__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr IM' -> IO ()
+
+casadi__DM__set_nz__0
+  :: DM -> DM -> Bool -> IM -> IO ()
+casadi__DM__set_nz__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set_nz__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set_nz__0 :: DMClass a => a -> DM -> Bool -> IM -> IO ()
+dm_set_nz__0 x = casadi__DM__set_nz__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__set_nz__1" c_casadi__DM__set_nz__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__DM__set_nz__1
+  :: DM -> DM -> Bool -> Slice -> IO ()
+casadi__DM__set_nz__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__set_nz__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+dm_set_nz__1 :: DMClass a => a -> DM -> Bool -> Slice -> IO ()
+dm_set_nz__1 x = casadi__DM__set_nz__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__size__0" c_casadi__DM__size__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO CInt
+
+casadi__DM__size__0
+  :: DM -> Int -> IO Int
+casadi__DM__size__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__size__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_size__0 :: DMClass a => a -> Int -> IO Int
+dm_size__0 x = casadi__DM__size__0 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__size__1" c_casadi__DM__size__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdPair CInt CInt))
+
+casadi__DM__size__1
+  :: DM -> IO (Int, Int)
+casadi__DM__size__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__size__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_size__1 :: DMClass a => a -> IO (Int, Int)
+dm_size__1 x = casadi__DM__size__1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__size1" c_casadi__DM__size1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__size1
+  :: DM -> IO Int
+casadi__DM__size1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__size1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_size1 :: DMClass a => a -> IO Int
+dm_size1 x = casadi__DM__size1 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__size2" c_casadi__DM__size2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi__DM__size2
+  :: DM -> IO Int
+casadi__DM__size2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__size2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_size2 :: DMClass a => a -> IO Int
+dm_size2 x = casadi__DM__size2 (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sparsity" c_casadi__DM__sparsity
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr Sparsity')
+
+casadi__DM__sparsity
+  :: DM -> IO Sparsity
+casadi__DM__sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sparsity :: DMClass a => a -> IO Sparsity
+dm_sparsity x = casadi__DM__sparsity (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__0" c_casadi__DM__sym__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DM')))))
+
+casadi__DM__sym__0
+  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DM))
+casadi__DM__sym__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DM))
+dm_sym__0 = casadi__DM__sym__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__1" c_casadi__DM__sym__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DM')))))
+
+casadi__DM__sym__1
+  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DM))
+casadi__DM__sym__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DM))
+dm_sym__1 = casadi__DM__sym__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__2" c_casadi__DM__sym__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi__DM__sym__2
+  :: String -> Int -> Int -> Int -> IO (Vector DM)
+casadi__DM__sym__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__2 :: String -> Int -> Int -> Int -> IO (Vector DM)
+dm_sym__2 = casadi__DM__sym__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__3" c_casadi__DM__sym__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi__DM__sym__3
+  :: String -> Sparsity -> Int -> IO (Vector DM)
+casadi__DM__sym__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__3 :: String -> Sparsity -> Int -> IO (Vector DM)
+dm_sym__3 = casadi__DM__sym__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__4" c_casadi__DM__sym__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi__DM__sym__4
+  :: String -> Sparsity -> IO DM
+casadi__DM__sym__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__4 :: String -> Sparsity -> IO DM
+dm_sym__4 = casadi__DM__sym__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__5" c_casadi__DM__sym__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi__DM__sym__5
+  :: String -> (Int, Int) -> IO DM
+casadi__DM__sym__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__5 :: String -> (Int, Int) -> IO DM
+dm_sym__5 = casadi__DM__sym__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__6" c_casadi__DM__sym__6
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__sym__6
+  :: String -> IO DM
+casadi__DM__sym__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__6 :: String -> IO DM
+dm_sym__6 = casadi__DM__sym__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__7" c_casadi__DM__sym__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr DM')
+
+casadi__DM__sym__7
+  :: String -> Int -> IO DM
+casadi__DM__sym__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__7 :: String -> Int -> IO DM
+dm_sym__7 = casadi__DM__sym__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__sym__8" c_casadi__DM__sym__8
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__sym__8
+  :: String -> Int -> Int -> IO DM
+casadi__DM__sym__8 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__sym__8 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_sym__8 :: String -> Int -> Int -> IO DM
+dm_sym__8 = casadi__DM__sym__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__tang__0" c_casadi__DM__tang__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__tang__0
+  :: Function -> String -> String -> IO DM
+casadi__DM__tang__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__tang__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_tang__0 :: Function -> String -> String -> IO DM
+dm_tang__0 = casadi__DM__tang__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__tang__1" c_casadi__DM__tang__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__tang__1
+  :: Function -> Int -> String -> IO DM
+casadi__DM__tang__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__tang__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_tang__1 :: Function -> Int -> String -> IO DM
+dm_tang__1 = casadi__DM__tang__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__tang__2" c_casadi__DM__tang__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr DM')
+
+casadi__DM__tang__2
+  :: Function -> String -> IO DM
+casadi__DM__tang__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__tang__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_tang__2 :: Function -> String -> IO DM
+dm_tang__2 = casadi__DM__tang__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__tang__3" c_casadi__DM__tang__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr DM')
+
+casadi__DM__tang__3
+  :: Function -> String -> Int -> IO DM
+casadi__DM__tang__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__tang__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_tang__3 :: Function -> String -> Int -> IO DM
+dm_tang__3 = casadi__DM__tang__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__tang__4" c_casadi__DM__tang__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr DM')
+
+casadi__DM__tang__4
+  :: Function -> IO DM
+casadi__DM__tang__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__tang__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_tang__4 :: Function -> IO DM
+dm_tang__4 = casadi__DM__tang__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__tang__5" c_casadi__DM__tang__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr DM')
+
+casadi__DM__tang__5
+  :: Function -> Int -> IO DM
+casadi__DM__tang__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__tang__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_tang__5 :: Function -> Int -> IO DM
+dm_tang__5 = casadi__DM__tang__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__tang__6" c_casadi__DM__tang__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__tang__6
+  :: Function -> Int -> Int -> IO DM
+casadi__DM__tang__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__tang__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_tang__6 :: Function -> Int -> Int -> IO DM
+dm_tang__6 = casadi__DM__tang__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__triplet__0" c_casadi__DM__triplet__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DM' -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi__DM__triplet__0
+  :: Vector Int -> Vector Int -> DM -> (Int, Int) -> IO DM
+casadi__DM__triplet__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__triplet__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_triplet__0 :: Vector Int -> Vector Int -> DM -> (Int, Int) -> IO DM
+dm_triplet__0 = casadi__DM__triplet__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__triplet__1" c_casadi__DM__triplet__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DM' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__triplet__1
+  :: Vector Int -> Vector Int -> DM -> Int -> Int -> IO DM
+casadi__DM__triplet__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_triplet__1 :: Vector Int -> Vector Int -> DM -> Int -> Int -> IO DM
+dm_triplet__1 = casadi__DM__triplet__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__triplet__2" c_casadi__DM__triplet__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__triplet__2
+  :: Vector Int -> Vector Int -> DM -> IO DM
+casadi__DM__triplet__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__triplet__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_triplet__2 :: Vector Int -> Vector Int -> DM -> IO DM
+dm_triplet__2 = casadi__DM__triplet__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__type_name" c_casadi__DM__type_name
+  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
+casadi__DM__type_name
+  :: IO String
+casadi__DM__type_name  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__type_name errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+dm_type_name :: IO String
+dm_type_name = casadi__DM__type_name
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__unary" c_casadi__DM__unary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr DM' -> IO (Ptr DM')
+
+casadi__DM__unary
+  :: Int -> DM -> IO DM
+casadi__DM__unary x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__unary errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_unary :: Int -> DM -> IO DM
+dm_unary = casadi__DM__unary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__zeros__0" c_casadi__DM__zeros__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi__DM__zeros__0
+  :: (Int, Int) -> IO DM
+casadi__DM__zeros__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__zeros__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_zeros__0 :: (Int, Int) -> IO DM
+dm_zeros__0 = casadi__DM__zeros__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__zeros__1" c_casadi__DM__zeros__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi__DM__zeros__1
+  :: Sparsity -> IO DM
+casadi__DM__zeros__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__zeros__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_zeros__1 :: Sparsity -> IO DM
+dm_zeros__1 = casadi__DM__zeros__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__zeros__2" c_casadi__DM__zeros__2
+  :: Ptr (Ptr StdString) -> IO (Ptr DM')
+
+casadi__DM__zeros__2
+  :: IO DM
+casadi__DM__zeros__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__zeros__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+dm_zeros__2 :: IO DM
+dm_zeros__2 = casadi__DM__zeros__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__zeros__3" c_casadi__DM__zeros__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DM')
+
+casadi__DM__zeros__3
+  :: Int -> IO DM
+casadi__DM__zeros__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__zeros__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_zeros__3 :: Int -> IO DM
+dm_zeros__3 = casadi__DM__zeros__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__zeros__4" c_casadi__DM__zeros__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__DM__zeros__4
+  :: Int -> Int -> IO DM
+casadi__DM__zeros__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__zeros__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_zeros__4 :: Int -> Int -> IO DM
+dm_zeros__4 = casadi__DM__zeros__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__getRepresentation" c_casadi__DM__getRepresentation
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr StdString)
+
+casadi__DM__getRepresentation
+  :: DM -> IO String
+casadi__DM__getRepresentation x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_getRepresentation :: DMClass a => a -> IO String
+dm_getRepresentation x = casadi__DM__getRepresentation (castDM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DM__getDescription" c_casadi__DM__getDescription
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr StdString)
+
+casadi__DM__getDescription
+  :: DM -> IO String
+casadi__DM__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DM__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+dm_getDescription :: DMClass a => a -> IO String
+dm_getDescription x = casadi__DM__getDescription (castDM x)
+
diff --git a/Casadi/Core/Classes/DMatrix.hs b/Casadi/Core/Classes/DMatrix.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/DMatrix.hs
+++ /dev/null
@@ -1,3973 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.DMatrix
-       (
-         DMatrix,
-         DMatrixClass(..),
-         dmatrix_T,
-         dmatrix__0,
-         dmatrix__1,
-         dmatrix__2,
-         dmatrix__3,
-         dmatrix__4,
-         dmatrix__5,
-         dmatrix__6,
-         dmatrix__7,
-         dmatrix__8,
-         dmatrix___nonzero__,
-         dmatrix_append,
-         dmatrix_appendColumns,
-         dmatrix_binary,
-         dmatrix_className,
-         dmatrix_clear,
-         dmatrix_colind,
-         dmatrix_dimString,
-         dmatrix_enlarge__0,
-         dmatrix_enlarge__1,
-         dmatrix_erase__0,
-         dmatrix_erase__1,
-         dmatrix_erase__2,
-         dmatrix_erase__3,
-         dmatrix_eye,
-         dmatrix_find__0,
-         dmatrix_find__1,
-         dmatrix_getColind,
-         dmatrix_getDep__0,
-         dmatrix_getDep__1,
-         dmatrix_getDescription,
-         dmatrix_getElementHash,
-         dmatrix_getEqualityCheckingDepth,
-         dmatrix_getIntValue,
-         dmatrix_getNZ__0,
-         dmatrix_getNZ__1,
-         dmatrix_getNZ__2,
-         dmatrix_getName,
-         dmatrix_getNdeps,
-         dmatrix_getRepresentation,
-         dmatrix_getRow,
-         dmatrix_getSparsity,
-         dmatrix_getSym,
-         dmatrix_getValue__0,
-         dmatrix_getValue__1,
-         dmatrix_get__0,
-         dmatrix_get__1,
-         dmatrix_get__2,
-         dmatrix_get__3,
-         dmatrix_get__4,
-         dmatrix_get__5,
-         dmatrix_get__6,
-         dmatrix_get__7,
-         dmatrix_hasDuplicates,
-         dmatrix_hasNZ,
-         dmatrix_hasNonStructuralZeros,
-         dmatrix_inf__0,
-         dmatrix_inf__1,
-         dmatrix_inf__2,
-         dmatrix_inf__3,
-         dmatrix_inf__4,
-         dmatrix_isCommutative,
-         dmatrix_isConstant,
-         dmatrix_isIdentity,
-         dmatrix_isInteger,
-         dmatrix_isLeaf,
-         dmatrix_isMinusOne,
-         dmatrix_isOne,
-         dmatrix_isRegular,
-         dmatrix_isSlice__0,
-         dmatrix_isSlice__1,
-         dmatrix_isSmooth,
-         dmatrix_isSymbolic,
-         dmatrix_isValidInput,
-         dmatrix_isZero,
-         dmatrix_iscolumn,
-         dmatrix_isdense,
-         dmatrix_isempty__0,
-         dmatrix_isempty__1,
-         dmatrix_isrow,
-         dmatrix_isscalar__0,
-         dmatrix_isscalar__1,
-         dmatrix_issquare,
-         dmatrix_istril,
-         dmatrix_istriu,
-         dmatrix_isvector,
-         dmatrix_makeSparse__0,
-         dmatrix_makeSparse__1,
-         dmatrix_matrix_matrix,
-         dmatrix_matrix_scalar,
-         dmatrix_nan__0,
-         dmatrix_nan__1,
-         dmatrix_nan__2,
-         dmatrix_nan__3,
-         dmatrix_nan__4,
-         dmatrix_nnz,
-         dmatrix_nonzeros,
-         dmatrix_nonzeros_int,
-         dmatrix_numel__0,
-         dmatrix_numel__1,
-         dmatrix_ones__0,
-         dmatrix_ones__1,
-         dmatrix_ones__2,
-         dmatrix_ones__3,
-         dmatrix_ones__4,
-         dmatrix_operator_minus,
-         dmatrix_operator_plus,
-         dmatrix_printDense,
-         dmatrix_printScalar,
-         dmatrix_printSparse,
-         dmatrix_printSplit,
-         dmatrix_printVector,
-         dmatrix_printme,
-         dmatrix_remove,
-         dmatrix_reserve__0,
-         dmatrix_reserve__1,
-         dmatrix_resetInput,
-         dmatrix_resize,
-         dmatrix_row,
-         dmatrix_sanityCheck__0,
-         dmatrix_sanityCheck__1,
-         dmatrix_scalar_matrix,
-         dmatrix_setEqualityCheckingDepth__0,
-         dmatrix_setEqualityCheckingDepth__1,
-         dmatrix_setNZ__0,
-         dmatrix_setNZ__1,
-         dmatrix_setNZ__2,
-         dmatrix_setNZ__3,
-         dmatrix_setPrecision,
-         dmatrix_setScientific,
-         dmatrix_setSym,
-         dmatrix_setValue__0,
-         dmatrix_setValue__1,
-         dmatrix_setWidth,
-         dmatrix_setZero,
-         dmatrix_set__0,
-         dmatrix_set__1,
-         dmatrix_set__10,
-         dmatrix_set__2,
-         dmatrix_set__3,
-         dmatrix_set__4,
-         dmatrix_set__5,
-         dmatrix_set__6,
-         dmatrix_set__7,
-         dmatrix_set__8,
-         dmatrix_set__9,
-         dmatrix_shape__0,
-         dmatrix_shape__1,
-         dmatrix_size,
-         dmatrix_size1,
-         dmatrix_size2,
-         dmatrix_sizeD,
-         dmatrix_sizeL,
-         dmatrix_sizeU,
-         dmatrix_sparse__0,
-         dmatrix_sparse__1,
-         dmatrix_sparse__2,
-         dmatrix_sparse__3,
-         dmatrix_sparse__4,
-         dmatrix_sparsity,
-         dmatrix_sym__0,
-         dmatrix_sym__1,
-         dmatrix_sym__2,
-         dmatrix_sym__3,
-         dmatrix_sym__4,
-         dmatrix_sym__5,
-         dmatrix_sym__6,
-         dmatrix_sym__7,
-         dmatrix_sym__8,
-         dmatrix_toSlice__0,
-         dmatrix_toSlice__1,
-         dmatrix_triplet__0,
-         dmatrix_triplet__1,
-         dmatrix_triplet__2,
-         dmatrix_unary,
-         dmatrix_zeros__0,
-         dmatrix_zeros__1,
-         dmatrix_zeros__2,
-         dmatrix_zeros__3,
-         dmatrix_zeros__4,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__0" c_casadi__DMatrix__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__0
-  :: Vector Int -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__0 :: Vector Int -> IO DMatrix
-dmatrix__0 = casadi__DMatrix__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__1" c_casadi__DMatrix__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__1
-  :: IMatrix -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__1 :: IMatrix -> IO DMatrix
-dmatrix__1 = casadi__DMatrix__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__2" c_casadi__DMatrix__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__2
-  :: Vector (Vector Double) -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__2 :: Vector (Vector Double) -> IO DMatrix
-dmatrix__2 = casadi__DMatrix__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__3" c_casadi__DMatrix__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__3
-  :: Double -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__3 :: Double -> IO DMatrix
-dmatrix__3 = casadi__DMatrix__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__4" c_casadi__DMatrix__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__4
-  :: Sparsity -> DMatrix -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__4 :: Sparsity -> DMatrix -> IO DMatrix
-dmatrix__4 = casadi__DMatrix__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__5" c_casadi__DMatrix__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__5
-  :: Sparsity -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__5 :: Sparsity -> IO DMatrix
-dmatrix__5 = casadi__DMatrix__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__6" c_casadi__DMatrix__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__6
-  :: Int -> Int -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__6 :: Int -> Int -> IO DMatrix
-dmatrix__6 = casadi__DMatrix__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__7" c_casadi__DMatrix__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__7
-  :: DMatrix -> IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__7 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__7 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__7 :: DMatrix -> IO DMatrix
-dmatrix__7 = casadi__DMatrix__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__8" c_casadi__DMatrix__CONSTRUCTOR__8
-  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
-casadi__DMatrix__CONSTRUCTOR__8
-  :: IO DMatrix
-casadi__DMatrix__CONSTRUCTOR__8  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__CONSTRUCTOR__8 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix__8 :: IO DMatrix
-dmatrix__8 = casadi__DMatrix__CONSTRUCTOR__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__T" c_casadi__DMatrix__T
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__T
-  :: DMatrix -> IO DMatrix
-casadi__DMatrix__T x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__T errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_T :: DMatrixClass a => a -> IO DMatrix
-dmatrix_T x = casadi__DMatrix__T (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix____nonzero__" c_casadi__DMatrix____nonzero__
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix____nonzero__
-  :: DMatrix -> IO Bool
-casadi__DMatrix____nonzero__ x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix____nonzero__ errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix___nonzero__ :: DMatrixClass a => a -> IO Bool
-dmatrix___nonzero__ x = casadi__DMatrix____nonzero__ (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__append" c_casadi__DMatrix__append
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__append
-  :: DMatrix -> DMatrix -> IO ()
-casadi__DMatrix__append x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__append errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_append :: DMatrixClass a => a -> DMatrix -> IO ()
-dmatrix_append x = casadi__DMatrix__append (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__appendColumns" c_casadi__DMatrix__appendColumns
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__appendColumns
-  :: DMatrix -> DMatrix -> IO ()
-casadi__DMatrix__appendColumns x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__appendColumns errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_appendColumns :: DMatrixClass a => a -> DMatrix -> IO ()
-dmatrix_appendColumns x = casadi__DMatrix__appendColumns (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__binary" c_casadi__DMatrix__binary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__binary
-  :: Int -> DMatrix -> DMatrix -> IO DMatrix
-casadi__DMatrix__binary x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__binary errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_binary :: Int -> DMatrix -> DMatrix -> IO DMatrix
-dmatrix_binary = casadi__DMatrix__binary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__className" c_casadi__DMatrix__className
-  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
-casadi__DMatrix__className
-  :: IO String
-casadi__DMatrix__className  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__className errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_className :: IO String
-dmatrix_className = casadi__DMatrix__className
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__clear" c_casadi__DMatrix__clear
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__clear
-  :: DMatrix -> IO ()
-casadi__DMatrix__clear x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__clear errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_clear :: DMatrixClass a => a -> IO ()
-dmatrix_clear x = casadi__DMatrix__clear (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__colind" c_casadi__DMatrix__colind
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt
-casadi__DMatrix__colind
-  :: DMatrix -> Int -> IO Int
-casadi__DMatrix__colind x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__colind errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_colind :: DMatrixClass a => a -> Int -> IO Int
-dmatrix_colind x = casadi__DMatrix__colind (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__dimString" c_casadi__DMatrix__dimString
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString)
-casadi__DMatrix__dimString
-  :: DMatrix -> IO String
-casadi__DMatrix__dimString x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__dimString errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_dimString :: DMatrixClass a => a -> IO String
-dmatrix_dimString x = casadi__DMatrix__dimString (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__enlarge__0" c_casadi__DMatrix__enlarge__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__DMatrix__enlarge__0
-  :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-casadi__DMatrix__enlarge__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_enlarge__0 :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-dmatrix_enlarge__0 x = casadi__DMatrix__enlarge__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__enlarge__1" c_casadi__DMatrix__enlarge__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__DMatrix__enlarge__1
-  :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__DMatrix__enlarge__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_enlarge__1 :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-dmatrix_enlarge__1 x = casadi__DMatrix__enlarge__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__erase__0" c_casadi__DMatrix__erase__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO ()
-casadi__DMatrix__erase__0
-  :: DMatrix -> Vector Int -> IO ()
-casadi__DMatrix__erase__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__erase__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_erase__0 :: DMatrixClass a => a -> Vector Int -> IO ()
-dmatrix_erase__0 x = casadi__DMatrix__erase__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__erase__1" c_casadi__DMatrix__erase__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__DMatrix__erase__1
-  :: DMatrix -> Vector Int -> Bool -> IO ()
-casadi__DMatrix__erase__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__erase__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_erase__1 :: DMatrixClass a => a -> Vector Int -> Bool -> IO ()
-dmatrix_erase__1 x = casadi__DMatrix__erase__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__erase__2" c_casadi__DMatrix__erase__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__DMatrix__erase__2
-  :: DMatrix -> Vector Int -> Vector Int -> IO ()
-casadi__DMatrix__erase__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__erase__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_erase__2 :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
-dmatrix_erase__2 x = casadi__DMatrix__erase__2 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__erase__3" c_casadi__DMatrix__erase__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__DMatrix__erase__3
-  :: DMatrix -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__DMatrix__erase__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__erase__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_erase__3 :: DMatrixClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
-dmatrix_erase__3 x = casadi__DMatrix__erase__3 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__eye" c_casadi__DMatrix__eye
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__eye
-  :: Int -> IO DMatrix
-casadi__DMatrix__eye x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__eye errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_eye :: Int -> IO DMatrix
-dmatrix_eye = casadi__DMatrix__eye
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__find__0" c_casadi__DMatrix__find__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt))
-casadi__DMatrix__find__0
-  :: DMatrix -> IO (Vector Int)
-casadi__DMatrix__find__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__find__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_find__0 :: DMatrixClass a => a -> IO (Vector Int)
-dmatrix_find__0 x = casadi__DMatrix__find__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__find__1" c_casadi__DMatrix__find__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__DMatrix__find__1
-  :: DMatrix -> Bool -> IO (Vector Int)
-casadi__DMatrix__find__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__find__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_find__1 :: DMatrixClass a => a -> Bool -> IO (Vector Int)
-dmatrix_find__1 x = casadi__DMatrix__find__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__0" c_casadi__DMatrix__get__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__get__0
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__DMatrix__get__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-dmatrix_get__0 x = casadi__DMatrix__get__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__1" c_casadi__DMatrix__get__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__DMatrix__get__1
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> Slice -> IO ()
-casadi__DMatrix__get__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__1 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> Slice -> IO ()
-dmatrix_get__1 x = casadi__DMatrix__get__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__2" c_casadi__DMatrix__get__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__get__2
-  :: DMatrix -> DMatrix -> Bool -> Slice -> IMatrix -> IO ()
-casadi__DMatrix__get__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__2 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IMatrix -> IO ()
-dmatrix_get__2 x = casadi__DMatrix__get__2 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__3" c_casadi__DMatrix__get__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__DMatrix__get__3
-  :: DMatrix -> DMatrix -> Bool -> Slice -> Slice -> IO ()
-casadi__DMatrix__get__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__3 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> Slice -> IO ()
-dmatrix_get__3 x = casadi__DMatrix__get__3 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__4" c_casadi__DMatrix__get__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__DMatrix__get__4
-  :: DMatrix -> DMatrix -> Bool -> Sparsity -> IO ()
-casadi__DMatrix__get__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__4 :: DMatrixClass a => a -> DMatrix -> Bool -> Sparsity -> IO ()
-dmatrix_get__4 x = casadi__DMatrix__get__4 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__5" c_casadi__DMatrix__get__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__get__5
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO ()
-casadi__DMatrix__get__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__5 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO ()
-dmatrix_get__5 x = casadi__DMatrix__get__5 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__6" c_casadi__DMatrix__get__6
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__DMatrix__get__6
-  :: DMatrix -> DMatrix -> Bool -> Slice -> IO ()
-casadi__DMatrix__get__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__6 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO ()
-dmatrix_get__6 x = casadi__DMatrix__get__6 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__get__7" c_casadi__DMatrix__get__7
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DMatrix__get__7
-  :: DMatrix -> Vector Double -> IO ()
-casadi__DMatrix__get__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__get__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_get__7 :: DMatrixClass a => a -> Vector Double -> IO ()
-dmatrix_get__7 x = casadi__DMatrix__get__7 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getColind" c_casadi__DMatrix__getColind
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt))
-casadi__DMatrix__getColind
-  :: DMatrix -> IO (Vector Int)
-casadi__DMatrix__getColind x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getColind errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getColind :: DMatrixClass a => a -> IO (Vector Int)
-dmatrix_getColind x = casadi__DMatrix__getColind (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getDep__0" c_casadi__DMatrix__getDep__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__getDep__0
-  :: DMatrix -> IO DMatrix
-casadi__DMatrix__getDep__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getDep__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getDep__0 :: DMatrixClass a => a -> IO DMatrix
-dmatrix_getDep__0 x = casadi__DMatrix__getDep__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getDep__1" c_casadi__DMatrix__getDep__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__getDep__1
-  :: DMatrix -> Int -> IO DMatrix
-casadi__DMatrix__getDep__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getDep__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getDep__1 :: DMatrixClass a => a -> Int -> IO DMatrix
-dmatrix_getDep__1 x = casadi__DMatrix__getDep__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getElementHash" c_casadi__DMatrix__getElementHash
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CSize
-casadi__DMatrix__getElementHash
-  :: DMatrix -> IO CSize
-casadi__DMatrix__getElementHash x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getElementHash errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getElementHash :: DMatrixClass a => a -> IO CSize
-dmatrix_getElementHash x = casadi__DMatrix__getElementHash (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getEqualityCheckingDepth" c_casadi__DMatrix__getEqualityCheckingDepth
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__DMatrix__getEqualityCheckingDepth
-  :: IO Int
-casadi__DMatrix__getEqualityCheckingDepth  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getEqualityCheckingDepth errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getEqualityCheckingDepth :: IO Int
-dmatrix_getEqualityCheckingDepth = casadi__DMatrix__getEqualityCheckingDepth
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getIntValue" c_casadi__DMatrix__getIntValue
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__getIntValue
-  :: DMatrix -> IO Int
-casadi__DMatrix__getIntValue x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getIntValue errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getIntValue :: DMatrixClass a => a -> IO Int
-dmatrix_getIntValue x = casadi__DMatrix__getIntValue (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getNZ__0" c_casadi__DMatrix__getNZ__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__getNZ__0
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO ()
-casadi__DMatrix__getNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getNZ__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO ()
-dmatrix_getNZ__0 x = casadi__DMatrix__getNZ__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getNZ__1" c_casadi__DMatrix__getNZ__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__DMatrix__getNZ__1
-  :: DMatrix -> DMatrix -> Bool -> Slice -> IO ()
-casadi__DMatrix__getNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getNZ__1 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO ()
-dmatrix_getNZ__1 x = casadi__DMatrix__getNZ__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getNZ__2" c_casadi__DMatrix__getNZ__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DMatrix__getNZ__2
-  :: DMatrix -> Vector Double -> IO ()
-casadi__DMatrix__getNZ__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getNZ__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getNZ__2 :: DMatrixClass a => a -> Vector Double -> IO ()
-dmatrix_getNZ__2 x = casadi__DMatrix__getNZ__2 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getName" c_casadi__DMatrix__getName
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString)
-casadi__DMatrix__getName
-  :: DMatrix -> IO String
-casadi__DMatrix__getName x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getName errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getName :: DMatrixClass a => a -> IO String
-dmatrix_getName x = casadi__DMatrix__getName (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getNdeps" c_casadi__DMatrix__getNdeps
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__getNdeps
-  :: DMatrix -> IO Int
-casadi__DMatrix__getNdeps x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getNdeps errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getNdeps :: DMatrixClass a => a -> IO Int
-dmatrix_getNdeps x = casadi__DMatrix__getNdeps (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getRow" c_casadi__DMatrix__getRow
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt))
-casadi__DMatrix__getRow
-  :: DMatrix -> IO (Vector Int)
-casadi__DMatrix__getRow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getRow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getRow :: DMatrixClass a => a -> IO (Vector Int)
-dmatrix_getRow x = casadi__DMatrix__getRow (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getSparsity" c_casadi__DMatrix__getSparsity
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Sparsity')
-casadi__DMatrix__getSparsity
-  :: DMatrix -> IO Sparsity
-casadi__DMatrix__getSparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getSparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getSparsity :: DMatrixClass a => a -> IO Sparsity
-dmatrix_getSparsity x = casadi__DMatrix__getSparsity (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getSym" c_casadi__DMatrix__getSym
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DMatrix__getSym
-  :: DMatrix -> Vector Double -> IO ()
-casadi__DMatrix__getSym x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getSym errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getSym :: DMatrixClass a => a -> Vector Double -> IO ()
-dmatrix_getSym x = casadi__DMatrix__getSym (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getValue__0" c_casadi__DMatrix__getValue__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CDouble
-casadi__DMatrix__getValue__0
-  :: DMatrix -> Int -> IO Double
-casadi__DMatrix__getValue__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getValue__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getValue__0 :: DMatrixClass a => a -> Int -> IO Double
-dmatrix_getValue__0 x = casadi__DMatrix__getValue__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getValue__1" c_casadi__DMatrix__getValue__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CDouble
-casadi__DMatrix__getValue__1
-  :: DMatrix -> IO Double
-casadi__DMatrix__getValue__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getValue__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getValue__1 :: DMatrixClass a => a -> IO Double
-dmatrix_getValue__1 x = casadi__DMatrix__getValue__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__hasDuplicates" c_casadi__DMatrix__hasDuplicates
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__hasDuplicates
-  :: DMatrix -> IO Bool
-casadi__DMatrix__hasDuplicates x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__hasDuplicates errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_hasDuplicates :: DMatrixClass a => a -> IO Bool
-dmatrix_hasDuplicates x = casadi__DMatrix__hasDuplicates (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__hasNZ" c_casadi__DMatrix__hasNZ
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO CInt
-casadi__DMatrix__hasNZ
-  :: DMatrix -> Int -> Int -> IO Bool
-casadi__DMatrix__hasNZ x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__hasNZ errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_hasNZ :: DMatrixClass a => a -> Int -> Int -> IO Bool
-dmatrix_hasNZ x = casadi__DMatrix__hasNZ (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__hasNonStructuralZeros" c_casadi__DMatrix__hasNonStructuralZeros
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__hasNonStructuralZeros
-  :: DMatrix -> IO Bool
-casadi__DMatrix__hasNonStructuralZeros x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__hasNonStructuralZeros errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_hasNonStructuralZeros :: DMatrixClass a => a -> IO Bool
-dmatrix_hasNonStructuralZeros x = casadi__DMatrix__hasNonStructuralZeros (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__inf__0" c_casadi__DMatrix__inf__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__inf__0
-  :: (Int, Int) -> IO DMatrix
-casadi__DMatrix__inf__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__inf__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_inf__0 :: (Int, Int) -> IO DMatrix
-dmatrix_inf__0 = casadi__DMatrix__inf__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__inf__1" c_casadi__DMatrix__inf__1
-  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
-casadi__DMatrix__inf__1
-  :: IO DMatrix
-casadi__DMatrix__inf__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__inf__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_inf__1 :: IO DMatrix
-dmatrix_inf__1 = casadi__DMatrix__inf__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__inf__2" c_casadi__DMatrix__inf__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__inf__2
-  :: Int -> IO DMatrix
-casadi__DMatrix__inf__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__inf__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_inf__2 :: Int -> IO DMatrix
-dmatrix_inf__2 = casadi__DMatrix__inf__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__inf__3" c_casadi__DMatrix__inf__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__inf__3
-  :: Int -> Int -> IO DMatrix
-casadi__DMatrix__inf__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__inf__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_inf__3 :: Int -> Int -> IO DMatrix
-dmatrix_inf__3 = casadi__DMatrix__inf__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__inf__4" c_casadi__DMatrix__inf__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi__DMatrix__inf__4
-  :: Sparsity -> IO DMatrix
-casadi__DMatrix__inf__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__inf__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_inf__4 :: Sparsity -> IO DMatrix
-dmatrix_inf__4 = casadi__DMatrix__inf__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isCommutative" c_casadi__DMatrix__isCommutative
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isCommutative
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isCommutative x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isCommutative errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isCommutative :: DMatrixClass a => a -> IO Bool
-dmatrix_isCommutative x = casadi__DMatrix__isCommutative (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isConstant" c_casadi__DMatrix__isConstant
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isConstant
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isConstant x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isConstant errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isConstant :: DMatrixClass a => a -> IO Bool
-dmatrix_isConstant x = casadi__DMatrix__isConstant (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isIdentity" c_casadi__DMatrix__isIdentity
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isIdentity
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isIdentity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isIdentity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isIdentity :: DMatrixClass a => a -> IO Bool
-dmatrix_isIdentity x = casadi__DMatrix__isIdentity (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isInteger" c_casadi__DMatrix__isInteger
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isInteger
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isInteger x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isInteger errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isInteger :: DMatrixClass a => a -> IO Bool
-dmatrix_isInteger x = casadi__DMatrix__isInteger (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isLeaf" c_casadi__DMatrix__isLeaf
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isLeaf
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isLeaf x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isLeaf errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isLeaf :: DMatrixClass a => a -> IO Bool
-dmatrix_isLeaf x = casadi__DMatrix__isLeaf (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isMinusOne" c_casadi__DMatrix__isMinusOne
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isMinusOne
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isMinusOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isMinusOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isMinusOne :: DMatrixClass a => a -> IO Bool
-dmatrix_isMinusOne x = casadi__DMatrix__isMinusOne (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isOne" c_casadi__DMatrix__isOne
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isOne
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isOne :: DMatrixClass a => a -> IO Bool
-dmatrix_isOne x = casadi__DMatrix__isOne (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isRegular" c_casadi__DMatrix__isRegular
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isRegular
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isRegular x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isRegular errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isRegular :: DMatrixClass a => a -> IO Bool
-dmatrix_isRegular x = casadi__DMatrix__isRegular (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isSlice__0" c_casadi__DMatrix__isSlice__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isSlice__0
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isSlice__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isSlice__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isSlice__0 :: DMatrixClass a => a -> IO Bool
-dmatrix_isSlice__0 x = casadi__DMatrix__isSlice__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isSlice__1" c_casadi__DMatrix__isSlice__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt
-casadi__DMatrix__isSlice__1
-  :: DMatrix -> Bool -> IO Bool
-casadi__DMatrix__isSlice__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isSlice__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isSlice__1 :: DMatrixClass a => a -> Bool -> IO Bool
-dmatrix_isSlice__1 x = casadi__DMatrix__isSlice__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isSmooth" c_casadi__DMatrix__isSmooth
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isSmooth
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isSmooth x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isSmooth errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isSmooth :: DMatrixClass a => a -> IO Bool
-dmatrix_isSmooth x = casadi__DMatrix__isSmooth (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isSymbolic" c_casadi__DMatrix__isSymbolic
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isSymbolic
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isSymbolic x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isSymbolic errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isSymbolic :: DMatrixClass a => a -> IO Bool
-dmatrix_isSymbolic x = casadi__DMatrix__isSymbolic (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isValidInput" c_casadi__DMatrix__isValidInput
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isValidInput
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isValidInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isValidInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isValidInput :: DMatrixClass a => a -> IO Bool
-dmatrix_isValidInput x = casadi__DMatrix__isValidInput (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isZero" c_casadi__DMatrix__isZero
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isZero
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isZero x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isZero errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isZero :: DMatrixClass a => a -> IO Bool
-dmatrix_isZero x = casadi__DMatrix__isZero (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__iscolumn" c_casadi__DMatrix__iscolumn
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__iscolumn
-  :: DMatrix -> IO Bool
-casadi__DMatrix__iscolumn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__iscolumn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_iscolumn :: DMatrixClass a => a -> IO Bool
-dmatrix_iscolumn x = casadi__DMatrix__iscolumn (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isdense" c_casadi__DMatrix__isdense
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isdense
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isdense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isdense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isdense :: DMatrixClass a => a -> IO Bool
-dmatrix_isdense x = casadi__DMatrix__isdense (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isempty__0" c_casadi__DMatrix__isempty__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isempty__0
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isempty__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isempty__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isempty__0 :: DMatrixClass a => a -> IO Bool
-dmatrix_isempty__0 x = casadi__DMatrix__isempty__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isempty__1" c_casadi__DMatrix__isempty__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt
-casadi__DMatrix__isempty__1
-  :: DMatrix -> Bool -> IO Bool
-casadi__DMatrix__isempty__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isempty__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isempty__1 :: DMatrixClass a => a -> Bool -> IO Bool
-dmatrix_isempty__1 x = casadi__DMatrix__isempty__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isrow" c_casadi__DMatrix__isrow
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isrow
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isrow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isrow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isrow :: DMatrixClass a => a -> IO Bool
-dmatrix_isrow x = casadi__DMatrix__isrow (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isscalar__0" c_casadi__DMatrix__isscalar__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isscalar__0
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isscalar__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isscalar__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isscalar__0 :: DMatrixClass a => a -> IO Bool
-dmatrix_isscalar__0 x = casadi__DMatrix__isscalar__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isscalar__1" c_casadi__DMatrix__isscalar__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt
-casadi__DMatrix__isscalar__1
-  :: DMatrix -> Bool -> IO Bool
-casadi__DMatrix__isscalar__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isscalar__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isscalar__1 :: DMatrixClass a => a -> Bool -> IO Bool
-dmatrix_isscalar__1 x = casadi__DMatrix__isscalar__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__issquare" c_casadi__DMatrix__issquare
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__issquare
-  :: DMatrix -> IO Bool
-casadi__DMatrix__issquare x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__issquare errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_issquare :: DMatrixClass a => a -> IO Bool
-dmatrix_issquare x = casadi__DMatrix__issquare (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__istril" c_casadi__DMatrix__istril
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__istril
-  :: DMatrix -> IO Bool
-casadi__DMatrix__istril x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__istril errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_istril :: DMatrixClass a => a -> IO Bool
-dmatrix_istril x = casadi__DMatrix__istril (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__istriu" c_casadi__DMatrix__istriu
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__istriu
-  :: DMatrix -> IO Bool
-casadi__DMatrix__istriu x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__istriu errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_istriu :: DMatrixClass a => a -> IO Bool
-dmatrix_istriu x = casadi__DMatrix__istriu (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__isvector" c_casadi__DMatrix__isvector
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__isvector
-  :: DMatrix -> IO Bool
-casadi__DMatrix__isvector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__isvector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_isvector :: DMatrixClass a => a -> IO Bool
-dmatrix_isvector x = casadi__DMatrix__isvector (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__makeSparse__0" c_casadi__DMatrix__makeSparse__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__makeSparse__0
-  :: DMatrix -> IO ()
-casadi__DMatrix__makeSparse__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__makeSparse__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_makeSparse__0 :: DMatrixClass a => a -> IO ()
-dmatrix_makeSparse__0 x = casadi__DMatrix__makeSparse__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__makeSparse__1" c_casadi__DMatrix__makeSparse__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO ()
-casadi__DMatrix__makeSparse__1
-  :: DMatrix -> Double -> IO ()
-casadi__DMatrix__makeSparse__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__makeSparse__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_makeSparse__1 :: DMatrixClass a => a -> Double -> IO ()
-dmatrix_makeSparse__1 x = casadi__DMatrix__makeSparse__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__matrix_matrix" c_casadi__DMatrix__matrix_matrix
-  :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__matrix_matrix
-  :: Int -> DMatrix -> DMatrix -> IO DMatrix
-casadi__DMatrix__matrix_matrix x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__matrix_matrix errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix
-dmatrix_matrix_matrix = casadi__DMatrix__matrix_matrix
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__matrix_scalar" c_casadi__DMatrix__matrix_scalar
-  :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__matrix_scalar
-  :: Int -> DMatrix -> DMatrix -> IO DMatrix
-casadi__DMatrix__matrix_scalar x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__matrix_scalar errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix
-dmatrix_matrix_scalar = casadi__DMatrix__matrix_scalar
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nan__0" c_casadi__DMatrix__nan__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__nan__0
-  :: (Int, Int) -> IO DMatrix
-casadi__DMatrix__nan__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nan__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nan__0 :: (Int, Int) -> IO DMatrix
-dmatrix_nan__0 = casadi__DMatrix__nan__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nan__1" c_casadi__DMatrix__nan__1
-  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
-casadi__DMatrix__nan__1
-  :: IO DMatrix
-casadi__DMatrix__nan__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nan__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nan__1 :: IO DMatrix
-dmatrix_nan__1 = casadi__DMatrix__nan__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nan__2" c_casadi__DMatrix__nan__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__nan__2
-  :: Int -> IO DMatrix
-casadi__DMatrix__nan__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nan__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nan__2 :: Int -> IO DMatrix
-dmatrix_nan__2 = casadi__DMatrix__nan__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nan__3" c_casadi__DMatrix__nan__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__nan__3
-  :: Int -> Int -> IO DMatrix
-casadi__DMatrix__nan__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nan__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nan__3 :: Int -> Int -> IO DMatrix
-dmatrix_nan__3 = casadi__DMatrix__nan__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nan__4" c_casadi__DMatrix__nan__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi__DMatrix__nan__4
-  :: Sparsity -> IO DMatrix
-casadi__DMatrix__nan__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nan__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nan__4 :: Sparsity -> IO DMatrix
-dmatrix_nan__4 = casadi__DMatrix__nan__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nnz" c_casadi__DMatrix__nnz
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__nnz
-  :: DMatrix -> IO Int
-casadi__DMatrix__nnz x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nnz errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nnz :: DMatrixClass a => a -> IO Int
-dmatrix_nnz x = casadi__DMatrix__nnz (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nonzeros" c_casadi__DMatrix__nonzeros
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CDouble))
-casadi__DMatrix__nonzeros
-  :: DMatrix -> IO (Vector Double)
-casadi__DMatrix__nonzeros x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nonzeros errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nonzeros :: DMatrixClass a => a -> IO (Vector Double)
-dmatrix_nonzeros x = casadi__DMatrix__nonzeros (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__nonzeros_int" c_casadi__DMatrix__nonzeros_int
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt))
-casadi__DMatrix__nonzeros_int
-  :: DMatrix -> IO (Vector Int)
-casadi__DMatrix__nonzeros_int x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__nonzeros_int errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_nonzeros_int :: DMatrixClass a => a -> IO (Vector Int)
-dmatrix_nonzeros_int x = casadi__DMatrix__nonzeros_int (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__numel__0" c_casadi__DMatrix__numel__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt
-casadi__DMatrix__numel__0
-  :: DMatrix -> Int -> IO Int
-casadi__DMatrix__numel__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__numel__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_numel__0 :: DMatrixClass a => a -> Int -> IO Int
-dmatrix_numel__0 x = casadi__DMatrix__numel__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__numel__1" c_casadi__DMatrix__numel__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__numel__1
-  :: DMatrix -> IO Int
-casadi__DMatrix__numel__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__numel__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_numel__1 :: DMatrixClass a => a -> IO Int
-dmatrix_numel__1 x = casadi__DMatrix__numel__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__ones__0" c_casadi__DMatrix__ones__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__ones__0
-  :: (Int, Int) -> IO DMatrix
-casadi__DMatrix__ones__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__ones__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_ones__0 :: (Int, Int) -> IO DMatrix
-dmatrix_ones__0 = casadi__DMatrix__ones__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__ones__1" c_casadi__DMatrix__ones__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi__DMatrix__ones__1
-  :: Sparsity -> IO DMatrix
-casadi__DMatrix__ones__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__ones__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_ones__1 :: Sparsity -> IO DMatrix
-dmatrix_ones__1 = casadi__DMatrix__ones__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__ones__2" c_casadi__DMatrix__ones__2
-  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
-casadi__DMatrix__ones__2
-  :: IO DMatrix
-casadi__DMatrix__ones__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__ones__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_ones__2 :: IO DMatrix
-dmatrix_ones__2 = casadi__DMatrix__ones__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__ones__3" c_casadi__DMatrix__ones__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__ones__3
-  :: Int -> IO DMatrix
-casadi__DMatrix__ones__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__ones__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_ones__3 :: Int -> IO DMatrix
-dmatrix_ones__3 = casadi__DMatrix__ones__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__ones__4" c_casadi__DMatrix__ones__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__ones__4
-  :: Int -> Int -> IO DMatrix
-casadi__DMatrix__ones__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__ones__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_ones__4 :: Int -> Int -> IO DMatrix
-dmatrix_ones__4 = casadi__DMatrix__ones__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__operator_plus" c_casadi__DMatrix__operator_plus
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__operator_plus
-  :: DMatrix -> IO DMatrix
-casadi__DMatrix__operator_plus x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__operator_plus errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_operator_plus :: DMatrixClass a => a -> IO DMatrix
-dmatrix_operator_plus x = casadi__DMatrix__operator_plus (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__operator_minus" c_casadi__DMatrix__operator_minus
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__operator_minus
-  :: DMatrix -> IO DMatrix
-casadi__DMatrix__operator_minus x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__operator_minus errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_operator_minus :: DMatrixClass a => a -> IO DMatrix
-dmatrix_operator_minus x = casadi__DMatrix__operator_minus (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__printDense" c_casadi__DMatrix__printDense
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__printDense
-  :: DMatrix -> IO ()
-casadi__DMatrix__printDense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__printDense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_printDense :: DMatrixClass a => a -> IO ()
-dmatrix_printDense x = casadi__DMatrix__printDense (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__printScalar" c_casadi__DMatrix__printScalar
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__printScalar
-  :: DMatrix -> IO ()
-casadi__DMatrix__printScalar x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__printScalar errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_printScalar :: DMatrixClass a => a -> IO ()
-dmatrix_printScalar x = casadi__DMatrix__printScalar (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__printSparse" c_casadi__DMatrix__printSparse
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__printSparse
-  :: DMatrix -> IO ()
-casadi__DMatrix__printSparse x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__printSparse errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_printSparse :: DMatrixClass a => a -> IO ()
-dmatrix_printSparse x = casadi__DMatrix__printSparse (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__printSplit" c_casadi__DMatrix__printSplit
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO ()
-casadi__DMatrix__printSplit
-  :: DMatrix -> Vector String -> Vector String -> IO ()
-casadi__DMatrix__printSplit x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__printSplit errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_printSplit :: DMatrixClass a => a -> Vector String -> Vector String -> IO ()
-dmatrix_printSplit x = casadi__DMatrix__printSplit (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__printVector" c_casadi__DMatrix__printVector
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__printVector
-  :: DMatrix -> IO ()
-casadi__DMatrix__printVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__printVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_printVector :: DMatrixClass a => a -> IO ()
-dmatrix_printVector x = casadi__DMatrix__printVector (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__printme" c_casadi__DMatrix__printme
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__printme
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi__DMatrix__printme x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__printme errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_printme :: DMatrixClass a => a -> DMatrix -> IO DMatrix
-dmatrix_printme x = casadi__DMatrix__printme (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__remove" c_casadi__DMatrix__remove
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__DMatrix__remove
-  :: DMatrix -> Vector Int -> Vector Int -> IO ()
-casadi__DMatrix__remove x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__remove errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_remove :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
-dmatrix_remove x = casadi__DMatrix__remove (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__reserve__0" c_casadi__DMatrix__reserve__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO ()
-casadi__DMatrix__reserve__0
-  :: DMatrix -> Int -> Int -> IO ()
-casadi__DMatrix__reserve__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__reserve__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_reserve__0 :: DMatrixClass a => a -> Int -> Int -> IO ()
-dmatrix_reserve__0 x = casadi__DMatrix__reserve__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__reserve__1" c_casadi__DMatrix__reserve__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO ()
-casadi__DMatrix__reserve__1
-  :: DMatrix -> Int -> IO ()
-casadi__DMatrix__reserve__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__reserve__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_reserve__1 :: DMatrixClass a => a -> Int -> IO ()
-dmatrix_reserve__1 x = casadi__DMatrix__reserve__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__resetInput" c_casadi__DMatrix__resetInput
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__resetInput
-  :: DMatrix -> IO ()
-casadi__DMatrix__resetInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__resetInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_resetInput :: DMatrixClass a => a -> IO ()
-dmatrix_resetInput x = casadi__DMatrix__resetInput (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__resize" c_casadi__DMatrix__resize
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO ()
-casadi__DMatrix__resize
-  :: DMatrix -> Int -> Int -> IO ()
-casadi__DMatrix__resize x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__resize errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_resize :: DMatrixClass a => a -> Int -> Int -> IO ()
-dmatrix_resize x = casadi__DMatrix__resize (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__row" c_casadi__DMatrix__row
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt
-casadi__DMatrix__row
-  :: DMatrix -> Int -> IO Int
-casadi__DMatrix__row x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__row errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_row :: DMatrixClass a => a -> Int -> IO Int
-dmatrix_row x = casadi__DMatrix__row (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sanityCheck__0" c_casadi__DMatrix__sanityCheck__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__sanityCheck__0
-  :: DMatrix -> IO ()
-casadi__DMatrix__sanityCheck__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sanityCheck__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sanityCheck__0 :: DMatrixClass a => a -> IO ()
-dmatrix_sanityCheck__0 x = casadi__DMatrix__sanityCheck__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sanityCheck__1" c_casadi__DMatrix__sanityCheck__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO ()
-casadi__DMatrix__sanityCheck__1
-  :: DMatrix -> Bool -> IO ()
-casadi__DMatrix__sanityCheck__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sanityCheck__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sanityCheck__1 :: DMatrixClass a => a -> Bool -> IO ()
-dmatrix_sanityCheck__1 x = casadi__DMatrix__sanityCheck__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__scalar_matrix" c_casadi__DMatrix__scalar_matrix
-  :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__scalar_matrix
-  :: Int -> DMatrix -> DMatrix -> IO DMatrix
-casadi__DMatrix__scalar_matrix x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__scalar_matrix errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix
-dmatrix_scalar_matrix = casadi__DMatrix__scalar_matrix
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__0" c_casadi__DMatrix__set__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__set__0
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__DMatrix__set__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-dmatrix_set__0 x = casadi__DMatrix__set__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__1" c_casadi__DMatrix__set__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__DMatrix__set__1
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> Slice -> IO ()
-casadi__DMatrix__set__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__1 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> Slice -> IO ()
-dmatrix_set__1 x = casadi__DMatrix__set__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__2" c_casadi__DMatrix__set__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__set__2
-  :: DMatrix -> DMatrix -> Bool -> Slice -> IMatrix -> IO ()
-casadi__DMatrix__set__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__2 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IMatrix -> IO ()
-dmatrix_set__2 x = casadi__DMatrix__set__2 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__3" c_casadi__DMatrix__set__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__DMatrix__set__3
-  :: DMatrix -> DMatrix -> Bool -> Slice -> Slice -> IO ()
-casadi__DMatrix__set__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__3 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> Slice -> IO ()
-dmatrix_set__3 x = casadi__DMatrix__set__3 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__4" c_casadi__DMatrix__set__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__DMatrix__set__4
-  :: DMatrix -> DMatrix -> Bool -> Sparsity -> IO ()
-casadi__DMatrix__set__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__4 :: DMatrixClass a => a -> DMatrix -> Bool -> Sparsity -> IO ()
-dmatrix_set__4 x = casadi__DMatrix__set__4 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__5" c_casadi__DMatrix__set__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__set__5
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO ()
-casadi__DMatrix__set__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__5 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO ()
-dmatrix_set__5 x = casadi__DMatrix__set__5 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__6" c_casadi__DMatrix__set__6
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__DMatrix__set__6
-  :: DMatrix -> DMatrix -> Bool -> Slice -> IO ()
-casadi__DMatrix__set__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__6 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO ()
-dmatrix_set__6 x = casadi__DMatrix__set__6 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__7" c_casadi__DMatrix__set__7
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DMatrix__set__7
-  :: DMatrix -> Vector Double -> IO ()
-casadi__DMatrix__set__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__7 :: DMatrixClass a => a -> Vector Double -> IO ()
-dmatrix_set__7 x = casadi__DMatrix__set__7 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__8" c_casadi__DMatrix__set__8
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__DMatrix__set__8
-  :: DMatrix -> Vector Double -> Bool -> IO ()
-casadi__DMatrix__set__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__8 :: DMatrixClass a => a -> Vector Double -> Bool -> IO ()
-dmatrix_set__8 x = casadi__DMatrix__set__8 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__9" c_casadi__DMatrix__set__9
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO ()
-casadi__DMatrix__set__9
-  :: DMatrix -> Double -> IO ()
-casadi__DMatrix__set__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__9 :: DMatrixClass a => a -> Double -> IO ()
-dmatrix_set__9 x = casadi__DMatrix__set__9 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__set__10" c_casadi__DMatrix__set__10
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__set__10
-  :: DMatrix -> DMatrix -> IO ()
-casadi__DMatrix__set__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__set__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_set__10 :: DMatrixClass a => a -> DMatrix -> IO ()
-dmatrix_set__10 x = casadi__DMatrix__set__10 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setEqualityCheckingDepth__0" c_casadi__DMatrix__setEqualityCheckingDepth__0
-  :: Ptr (Ptr StdString) -> IO ()
-casadi__DMatrix__setEqualityCheckingDepth__0
-  :: IO ()
-casadi__DMatrix__setEqualityCheckingDepth__0  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setEqualityCheckingDepth__0 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setEqualityCheckingDepth__0 :: IO ()
-dmatrix_setEqualityCheckingDepth__0 = casadi__DMatrix__setEqualityCheckingDepth__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setEqualityCheckingDepth__1" c_casadi__DMatrix__setEqualityCheckingDepth__1
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__DMatrix__setEqualityCheckingDepth__1
-  :: Int -> IO ()
-casadi__DMatrix__setEqualityCheckingDepth__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setEqualityCheckingDepth__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setEqualityCheckingDepth__1 :: Int -> IO ()
-dmatrix_setEqualityCheckingDepth__1 = casadi__DMatrix__setEqualityCheckingDepth__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setNZ__0" c_casadi__DMatrix__setNZ__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__DMatrix__setNZ__0
-  :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO ()
-casadi__DMatrix__setNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setNZ__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO ()
-dmatrix_setNZ__0 x = casadi__DMatrix__setNZ__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setNZ__1" c_casadi__DMatrix__setNZ__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__DMatrix__setNZ__1
-  :: DMatrix -> DMatrix -> Bool -> Slice -> IO ()
-casadi__DMatrix__setNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setNZ__1 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO ()
-dmatrix_setNZ__1 x = casadi__DMatrix__setNZ__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setNZ__2" c_casadi__DMatrix__setNZ__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DMatrix__setNZ__2
-  :: DMatrix -> Vector Double -> IO ()
-casadi__DMatrix__setNZ__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setNZ__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setNZ__2 :: DMatrixClass a => a -> Vector Double -> IO ()
-dmatrix_setNZ__2 x = casadi__DMatrix__setNZ__2 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setNZ__3" c_casadi__DMatrix__setNZ__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO ()
-casadi__DMatrix__setNZ__3
-  :: DMatrix -> Double -> IO ()
-casadi__DMatrix__setNZ__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setNZ__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setNZ__3 :: DMatrixClass a => a -> Double -> IO ()
-dmatrix_setNZ__3 x = casadi__DMatrix__setNZ__3 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setPrecision" c_casadi__DMatrix__setPrecision
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__DMatrix__setPrecision
-  :: Int -> IO ()
-casadi__DMatrix__setPrecision x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setPrecision errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setPrecision :: Int -> IO ()
-dmatrix_setPrecision = casadi__DMatrix__setPrecision
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setScientific" c_casadi__DMatrix__setScientific
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__DMatrix__setScientific
-  :: Bool -> IO ()
-casadi__DMatrix__setScientific x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setScientific errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setScientific :: Bool -> IO ()
-dmatrix_setScientific = casadi__DMatrix__setScientific
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setSym" c_casadi__DMatrix__setSym
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DMatrix__setSym
-  :: DMatrix -> Vector Double -> IO ()
-casadi__DMatrix__setSym x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setSym errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setSym :: DMatrixClass a => a -> Vector Double -> IO ()
-dmatrix_setSym x = casadi__DMatrix__setSym (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setValue__0" c_casadi__DMatrix__setValue__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> CInt -> IO ()
-casadi__DMatrix__setValue__0
-  :: DMatrix -> Double -> Int -> IO ()
-casadi__DMatrix__setValue__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setValue__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setValue__0 :: DMatrixClass a => a -> Double -> Int -> IO ()
-dmatrix_setValue__0 x = casadi__DMatrix__setValue__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setValue__1" c_casadi__DMatrix__setValue__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO ()
-casadi__DMatrix__setValue__1
-  :: DMatrix -> Double -> IO ()
-casadi__DMatrix__setValue__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setValue__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setValue__1 :: DMatrixClass a => a -> Double -> IO ()
-dmatrix_setValue__1 x = casadi__DMatrix__setValue__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setWidth" c_casadi__DMatrix__setWidth
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__DMatrix__setWidth
-  :: Int -> IO ()
-casadi__DMatrix__setWidth x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setWidth errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setWidth :: Int -> IO ()
-dmatrix_setWidth = casadi__DMatrix__setWidth
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__setZero" c_casadi__DMatrix__setZero
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO ()
-casadi__DMatrix__setZero
-  :: DMatrix -> IO ()
-casadi__DMatrix__setZero x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__setZero errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_setZero :: DMatrixClass a => a -> IO ()
-dmatrix_setZero x = casadi__DMatrix__setZero (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__shape__0" c_casadi__DMatrix__shape__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt
-casadi__DMatrix__shape__0
-  :: DMatrix -> Int -> IO Int
-casadi__DMatrix__shape__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__shape__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_shape__0 :: DMatrixClass a => a -> Int -> IO Int
-dmatrix_shape__0 x = casadi__DMatrix__shape__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__shape__1" c_casadi__DMatrix__shape__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdPair CInt CInt))
-casadi__DMatrix__shape__1
-  :: DMatrix -> IO (Int, Int)
-casadi__DMatrix__shape__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__shape__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_shape__1 :: DMatrixClass a => a -> IO (Int, Int)
-dmatrix_shape__1 x = casadi__DMatrix__shape__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__size" c_casadi__DMatrix__size
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__size
-  :: DMatrix -> IO Int
-casadi__DMatrix__size x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__size errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_size :: DMatrixClass a => a -> IO Int
-dmatrix_size x = casadi__DMatrix__size (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__size1" c_casadi__DMatrix__size1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__size1
-  :: DMatrix -> IO Int
-casadi__DMatrix__size1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__size1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_size1 :: DMatrixClass a => a -> IO Int
-dmatrix_size1 x = casadi__DMatrix__size1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__size2" c_casadi__DMatrix__size2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__size2
-  :: DMatrix -> IO Int
-casadi__DMatrix__size2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__size2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_size2 :: DMatrixClass a => a -> IO Int
-dmatrix_size2 x = casadi__DMatrix__size2 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sizeD" c_casadi__DMatrix__sizeD
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__sizeD
-  :: DMatrix -> IO Int
-casadi__DMatrix__sizeD x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sizeD errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sizeD :: DMatrixClass a => a -> IO Int
-dmatrix_sizeD x = casadi__DMatrix__sizeD (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sizeL" c_casadi__DMatrix__sizeL
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__sizeL
-  :: DMatrix -> IO Int
-casadi__DMatrix__sizeL x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sizeL errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sizeL :: DMatrixClass a => a -> IO Int
-dmatrix_sizeL x = casadi__DMatrix__sizeL (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sizeU" c_casadi__DMatrix__sizeU
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi__DMatrix__sizeU
-  :: DMatrix -> IO Int
-casadi__DMatrix__sizeU x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sizeU errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sizeU :: DMatrixClass a => a -> IO Int
-dmatrix_sizeU x = casadi__DMatrix__sizeU (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sparse__0" c_casadi__DMatrix__sparse__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__sparse__0
-  :: Sparsity -> DMatrix -> IO DMatrix
-casadi__DMatrix__sparse__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sparse__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sparse__0 :: Sparsity -> DMatrix -> IO DMatrix
-dmatrix_sparse__0 = casadi__DMatrix__sparse__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sparse__1" c_casadi__DMatrix__sparse__1
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__sparse__1
-  :: (Int, Int) -> IO DMatrix
-casadi__DMatrix__sparse__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sparse__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sparse__1 :: (Int, Int) -> IO DMatrix
-dmatrix_sparse__1 = casadi__DMatrix__sparse__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sparse__2" c_casadi__DMatrix__sparse__2
-  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
-casadi__DMatrix__sparse__2
-  :: IO DMatrix
-casadi__DMatrix__sparse__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sparse__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sparse__2 :: IO DMatrix
-dmatrix_sparse__2 = casadi__DMatrix__sparse__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sparse__3" c_casadi__DMatrix__sparse__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__sparse__3
-  :: Int -> IO DMatrix
-casadi__DMatrix__sparse__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sparse__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sparse__3 :: Int -> IO DMatrix
-dmatrix_sparse__3 = casadi__DMatrix__sparse__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sparse__4" c_casadi__DMatrix__sparse__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__sparse__4
-  :: Int -> Int -> IO DMatrix
-casadi__DMatrix__sparse__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sparse__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sparse__4 :: Int -> Int -> IO DMatrix
-dmatrix_sparse__4 = casadi__DMatrix__sparse__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sparsity" c_casadi__DMatrix__sparsity
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Sparsity')
-casadi__DMatrix__sparsity
-  :: DMatrix -> IO Sparsity
-casadi__DMatrix__sparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sparsity :: DMatrixClass a => a -> IO Sparsity
-dmatrix_sparsity x = casadi__DMatrix__sparsity (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__0" c_casadi__DMatrix__sym__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-casadi__DMatrix__sym__0
-  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix))
-casadi__DMatrix__sym__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix))
-dmatrix_sym__0 = casadi__DMatrix__sym__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__1" c_casadi__DMatrix__sym__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-casadi__DMatrix__sym__1
-  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix))
-casadi__DMatrix__sym__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix))
-dmatrix_sym__1 = casadi__DMatrix__sym__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__2" c_casadi__DMatrix__sym__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi__DMatrix__sym__2
-  :: String -> Int -> Int -> Int -> IO (Vector DMatrix)
-casadi__DMatrix__sym__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector DMatrix)
-dmatrix_sym__2 = casadi__DMatrix__sym__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__3" c_casadi__DMatrix__sym__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi__DMatrix__sym__3
-  :: String -> Sparsity -> Int -> IO (Vector DMatrix)
-casadi__DMatrix__sym__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector DMatrix)
-dmatrix_sym__3 = casadi__DMatrix__sym__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__4" c_casadi__DMatrix__sym__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi__DMatrix__sym__4
-  :: String -> Sparsity -> IO DMatrix
-casadi__DMatrix__sym__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__4 :: String -> Sparsity -> IO DMatrix
-dmatrix_sym__4 = casadi__DMatrix__sym__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__5" c_casadi__DMatrix__sym__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__sym__5
-  :: String -> (Int, Int) -> IO DMatrix
-casadi__DMatrix__sym__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__5 :: String -> (Int, Int) -> IO DMatrix
-dmatrix_sym__5 = casadi__DMatrix__sym__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__6" c_casadi__DMatrix__sym__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr DMatrix')
-casadi__DMatrix__sym__6
-  :: String -> IO DMatrix
-casadi__DMatrix__sym__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__6 :: String -> IO DMatrix
-dmatrix_sym__6 = casadi__DMatrix__sym__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__7" c_casadi__DMatrix__sym__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__sym__7
-  :: String -> Int -> IO DMatrix
-casadi__DMatrix__sym__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__7 :: String -> Int -> IO DMatrix
-dmatrix_sym__7 = casadi__DMatrix__sym__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__sym__8" c_casadi__DMatrix__sym__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__sym__8
-  :: String -> Int -> Int -> IO DMatrix
-casadi__DMatrix__sym__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__sym__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_sym__8 :: String -> Int -> Int -> IO DMatrix
-dmatrix_sym__8 = casadi__DMatrix__sym__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__toSlice__0" c_casadi__DMatrix__toSlice__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Slice')
-casadi__DMatrix__toSlice__0
-  :: DMatrix -> IO Slice
-casadi__DMatrix__toSlice__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__toSlice__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_toSlice__0 :: DMatrixClass a => a -> IO Slice
-dmatrix_toSlice__0 x = casadi__DMatrix__toSlice__0 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__toSlice__1" c_casadi__DMatrix__toSlice__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr Slice')
-casadi__DMatrix__toSlice__1
-  :: DMatrix -> Bool -> IO Slice
-casadi__DMatrix__toSlice__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__toSlice__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_toSlice__1 :: DMatrixClass a => a -> Bool -> IO Slice
-dmatrix_toSlice__1 x = casadi__DMatrix__toSlice__1 (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__triplet__0" c_casadi__DMatrix__triplet__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__triplet__0
-  :: Vector Int -> Vector Int -> DMatrix -> (Int, Int) -> IO DMatrix
-casadi__DMatrix__triplet__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__triplet__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_triplet__0 :: Vector Int -> Vector Int -> DMatrix -> (Int, Int) -> IO DMatrix
-dmatrix_triplet__0 = casadi__DMatrix__triplet__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__triplet__1" c_casadi__DMatrix__triplet__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__triplet__1
-  :: Vector Int -> Vector Int -> DMatrix -> Int -> Int -> IO DMatrix
-casadi__DMatrix__triplet__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_triplet__1 :: Vector Int -> Vector Int -> DMatrix -> Int -> Int -> IO DMatrix
-dmatrix_triplet__1 = casadi__DMatrix__triplet__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__triplet__2" c_casadi__DMatrix__triplet__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__triplet__2
-  :: Vector Int -> Vector Int -> DMatrix -> IO DMatrix
-casadi__DMatrix__triplet__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__triplet__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_triplet__2 :: Vector Int -> Vector Int -> DMatrix -> IO DMatrix
-dmatrix_triplet__2 = casadi__DMatrix__triplet__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__unary" c_casadi__DMatrix__unary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi__DMatrix__unary
-  :: Int -> DMatrix -> IO DMatrix
-casadi__DMatrix__unary x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__unary errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_unary :: Int -> DMatrix -> IO DMatrix
-dmatrix_unary = casadi__DMatrix__unary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__zeros__0" c_casadi__DMatrix__zeros__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi__DMatrix__zeros__0
-  :: (Int, Int) -> IO DMatrix
-casadi__DMatrix__zeros__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__zeros__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_zeros__0 :: (Int, Int) -> IO DMatrix
-dmatrix_zeros__0 = casadi__DMatrix__zeros__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__zeros__1" c_casadi__DMatrix__zeros__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi__DMatrix__zeros__1
-  :: Sparsity -> IO DMatrix
-casadi__DMatrix__zeros__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__zeros__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_zeros__1 :: Sparsity -> IO DMatrix
-dmatrix_zeros__1 = casadi__DMatrix__zeros__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__zeros__2" c_casadi__DMatrix__zeros__2
-  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
-casadi__DMatrix__zeros__2
-  :: IO DMatrix
-casadi__DMatrix__zeros__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__zeros__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_zeros__2 :: IO DMatrix
-dmatrix_zeros__2 = casadi__DMatrix__zeros__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__zeros__3" c_casadi__DMatrix__zeros__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__zeros__3
-  :: Int -> IO DMatrix
-casadi__DMatrix__zeros__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__zeros__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_zeros__3 :: Int -> IO DMatrix
-dmatrix_zeros__3 = casadi__DMatrix__zeros__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__zeros__4" c_casadi__DMatrix__zeros__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi__DMatrix__zeros__4
-  :: Int -> Int -> IO DMatrix
-casadi__DMatrix__zeros__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__zeros__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_zeros__4 :: Int -> Int -> IO DMatrix
-dmatrix_zeros__4 = casadi__DMatrix__zeros__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getRepresentation" c_casadi__DMatrix__getRepresentation
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString)
-casadi__DMatrix__getRepresentation
-  :: DMatrix -> IO String
-casadi__DMatrix__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getRepresentation :: DMatrixClass a => a -> IO String
-dmatrix_getRepresentation x = casadi__DMatrix__getRepresentation (castDMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DMatrix__getDescription" c_casadi__DMatrix__getDescription
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString)
-casadi__DMatrix__getDescription
-  :: DMatrix -> IO String
-casadi__DMatrix__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DMatrix__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dmatrix_getDescription :: DMatrixClass a => a -> IO String
-dmatrix_getDescription x = casadi__DMatrix__getDescription (castDMatrix x)
-
diff --git a/Casadi/Core/Classes/DaeBuilder.hs b/Casadi/Core/Classes/DaeBuilder.hs
--- a/Casadi/Core/Classes/DaeBuilder.hs
+++ b/Casadi/Core/Classes/DaeBuilder.hs
@@ -10,2367 +10,3246 @@
          DaeBuilder,
          DaeBuilderClass(..),
          daeBuilder,
-         daeBuilder_addLinearCombination,
-         daeBuilder_addVariable__0,
-         daeBuilder_addVariable__1,
-         daeBuilder_addVariable__2,
-         daeBuilder_addVariable__3,
-         daeBuilder_add_alg__0,
-         daeBuilder_add_alg__1,
-         daeBuilder_add_d__0,
-         daeBuilder_add_d__1,
-         daeBuilder_add_dae__0,
-         daeBuilder_add_dae__1,
-         daeBuilder_add_ode__0,
-         daeBuilder_add_ode__1,
-         daeBuilder_add_p__0,
-         daeBuilder_add_p__1,
-         daeBuilder_add_p__2,
-         daeBuilder_add_q__0,
-         daeBuilder_add_q__1,
-         daeBuilder_add_q__2,
-         daeBuilder_add_quad__0,
-         daeBuilder_add_quad__1,
-         daeBuilder_add_s__0,
-         daeBuilder_add_s__1,
-         daeBuilder_add_s__2,
-         daeBuilder_add_u__0,
-         daeBuilder_add_u__1,
-         daeBuilder_add_u__2,
-         daeBuilder_add_x__0,
-         daeBuilder_add_x__1,
-         daeBuilder_add_x__2,
-         daeBuilder_add_y__0,
-         daeBuilder_add_y__1,
-         daeBuilder_add_z__0,
-         daeBuilder_add_z__1,
-         daeBuilder_add_z__2,
-         daeBuilder_create,
-         daeBuilder_der__0,
-         daeBuilder_der__1,
-         daeBuilder_derivativeStart__0,
-         daeBuilder_derivativeStart__1,
-         daeBuilder_derivativeStart__2,
-         daeBuilder_derivativeStart__3,
-         daeBuilder_eliminate_alg,
-         daeBuilder_eliminate_d,
-         daeBuilder_eliminate_quad,
-         daeBuilder_getDescription,
-         daeBuilder_getRepresentation,
-         daeBuilder_initialGuess__0,
-         daeBuilder_initialGuess__1,
-         daeBuilder_initialGuess__2,
-         daeBuilder_initialGuess__3,
-         daeBuilder_makeExplicit,
-         daeBuilder_makeSemiExplicit,
-         daeBuilder_max__0,
-         daeBuilder_max__1,
-         daeBuilder_max__2,
-         daeBuilder_max__3,
-         daeBuilder_min__0,
-         daeBuilder_min__1,
-         daeBuilder_min__2,
-         daeBuilder_min__3,
-         daeBuilder_nominal__0,
-         daeBuilder_nominal__1,
-         daeBuilder_operator_call,
-         daeBuilder_parseFMI,
-         daeBuilder_sanityCheck,
-         daeBuilder_scaleEquations,
-         daeBuilder_scaleVariables,
-         daeBuilder_setDerivativeStart__0,
-         daeBuilder_setDerivativeStart__1,
-         daeBuilder_setDerivativeStart__2,
-         daeBuilder_setDerivativeStart__3,
-         daeBuilder_setInitialGuess__0,
-         daeBuilder_setInitialGuess__1,
-         daeBuilder_setInitialGuess__2,
-         daeBuilder_setInitialGuess__3,
-         daeBuilder_setMax__0,
-         daeBuilder_setMax__1,
-         daeBuilder_setMax__2,
-         daeBuilder_setMax__3,
-         daeBuilder_setMin__0,
-         daeBuilder_setMin__1,
-         daeBuilder_setMin__2,
-         daeBuilder_setMin__3,
-         daeBuilder_setNominal__0,
-         daeBuilder_setNominal__1,
-         daeBuilder_setStart__0,
-         daeBuilder_setStart__1,
-         daeBuilder_setStart__2,
-         daeBuilder_setStart__3,
-         daeBuilder_setUnit,
-         daeBuilder_sort_alg,
-         daeBuilder_sort_d,
-         daeBuilder_sort_dae,
-         daeBuilder_split_d,
-         daeBuilder_split_dae,
-         daeBuilder_start__0,
-         daeBuilder_start__1,
-         daeBuilder_start__2,
-         daeBuilder_start__3,
-         daeBuilder_unit__0,
-         daeBuilder_unit__1,
-         daeBuilder_variable__0,
-         daeBuilder_variable__1,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__CONSTRUCTOR" c_casadi__DaeBuilder__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr DaeBuilder')
-casadi__DaeBuilder__CONSTRUCTOR
-  :: IO DaeBuilder
-casadi__DaeBuilder__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder :: IO DaeBuilder
-daeBuilder = casadi__DaeBuilder__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__addLinearCombination" c_casadi__DaeBuilder__addLinearCombination
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr MX')
-casadi__DaeBuilder__addLinearCombination
-  :: DaeBuilder -> String -> Vector String -> IO MX
-casadi__DaeBuilder__addLinearCombination x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__addLinearCombination errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_addLinearCombination :: DaeBuilderClass a => a -> String -> Vector String -> IO MX
-daeBuilder_addLinearCombination x = casadi__DaeBuilder__addLinearCombination (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__addVariable__0" c_casadi__DaeBuilder__addVariable__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__DaeBuilder__addVariable__0
-  :: DaeBuilder -> String -> Sparsity -> IO MX
-casadi__DaeBuilder__addVariable__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__addVariable__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_addVariable__0 :: DaeBuilderClass a => a -> String -> Sparsity -> IO MX
-daeBuilder_addVariable__0 x = casadi__DaeBuilder__addVariable__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__addVariable__1" c_casadi__DaeBuilder__addVariable__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__addVariable__1
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__addVariable__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__addVariable__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_addVariable__1 :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_addVariable__1 x = casadi__DaeBuilder__addVariable__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__addVariable__2" c_casadi__DaeBuilder__addVariable__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__DaeBuilder__addVariable__2
-  :: DaeBuilder -> String -> Int -> IO MX
-casadi__DaeBuilder__addVariable__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__addVariable__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_addVariable__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
-daeBuilder_addVariable__2 x = casadi__DaeBuilder__addVariable__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__addVariable__3" c_casadi__DaeBuilder__addVariable__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr Variable' -> IO ()
-casadi__DaeBuilder__addVariable__3
-  :: DaeBuilder -> String -> Variable -> IO ()
-casadi__DaeBuilder__addVariable__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__addVariable__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_addVariable__3 :: DaeBuilderClass a => a -> String -> Variable -> IO ()
-daeBuilder_addVariable__3 x = casadi__DaeBuilder__addVariable__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_alg__0" c_casadi__DaeBuilder__add_alg__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
-casadi__DaeBuilder__add_alg__0
-  :: DaeBuilder -> MX -> IO ()
-casadi__DaeBuilder__add_alg__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_alg__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_alg__0 :: DaeBuilderClass a => a -> MX -> IO ()
-daeBuilder_add_alg__0 x = casadi__DaeBuilder__add_alg__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_alg__1" c_casadi__DaeBuilder__add_alg__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
-casadi__DaeBuilder__add_alg__1
-  :: DaeBuilder -> MX -> String -> IO ()
-casadi__DaeBuilder__add_alg__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_alg__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_alg__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
-daeBuilder_add_alg__1 x = casadi__DaeBuilder__add_alg__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_d__0" c_casadi__DaeBuilder__add_d__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX')
-casadi__DaeBuilder__add_d__0
-  :: DaeBuilder -> MX -> IO MX
-casadi__DaeBuilder__add_d__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_d__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_d__0 :: DaeBuilderClass a => a -> MX -> IO MX
-daeBuilder_add_d__0 x = casadi__DaeBuilder__add_d__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_d__1" c_casadi__DaeBuilder__add_d__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__add_d__1
-  :: DaeBuilder -> MX -> String -> IO MX
-casadi__DaeBuilder__add_d__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_d__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_d__1 :: DaeBuilderClass a => a -> MX -> String -> IO MX
-daeBuilder_add_d__1 x = casadi__DaeBuilder__add_d__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_dae__0" c_casadi__DaeBuilder__add_dae__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
-casadi__DaeBuilder__add_dae__0
-  :: DaeBuilder -> MX -> IO ()
-casadi__DaeBuilder__add_dae__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_dae__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_dae__0 :: DaeBuilderClass a => a -> MX -> IO ()
-daeBuilder_add_dae__0 x = casadi__DaeBuilder__add_dae__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_dae__1" c_casadi__DaeBuilder__add_dae__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
-casadi__DaeBuilder__add_dae__1
-  :: DaeBuilder -> MX -> String -> IO ()
-casadi__DaeBuilder__add_dae__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_dae__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_dae__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
-daeBuilder_add_dae__1 x = casadi__DaeBuilder__add_dae__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_ode__0" c_casadi__DaeBuilder__add_ode__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
-casadi__DaeBuilder__add_ode__0
-  :: DaeBuilder -> MX -> IO ()
-casadi__DaeBuilder__add_ode__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_ode__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_ode__0 :: DaeBuilderClass a => a -> MX -> IO ()
-daeBuilder_add_ode__0 x = casadi__DaeBuilder__add_ode__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_ode__1" c_casadi__DaeBuilder__add_ode__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
-casadi__DaeBuilder__add_ode__1
-  :: DaeBuilder -> MX -> String -> IO ()
-casadi__DaeBuilder__add_ode__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_ode__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_ode__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
-daeBuilder_add_ode__1 x = casadi__DaeBuilder__add_ode__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_p__0" c_casadi__DaeBuilder__add_p__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
-casadi__DaeBuilder__add_p__0
-  :: DaeBuilder -> IO MX
-casadi__DaeBuilder__add_p__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_p__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_p__0 :: DaeBuilderClass a => a -> IO MX
-daeBuilder_add_p__0 x = casadi__DaeBuilder__add_p__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_p__1" c_casadi__DaeBuilder__add_p__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__add_p__1
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__add_p__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_p__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_p__1 :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_add_p__1 x = casadi__DaeBuilder__add_p__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_p__2" c_casadi__DaeBuilder__add_p__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__DaeBuilder__add_p__2
-  :: DaeBuilder -> String -> Int -> IO MX
-casadi__DaeBuilder__add_p__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_p__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_p__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
-daeBuilder_add_p__2 x = casadi__DaeBuilder__add_p__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_q__0" c_casadi__DaeBuilder__add_q__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
-casadi__DaeBuilder__add_q__0
-  :: DaeBuilder -> IO MX
-casadi__DaeBuilder__add_q__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_q__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_q__0 :: DaeBuilderClass a => a -> IO MX
-daeBuilder_add_q__0 x = casadi__DaeBuilder__add_q__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_q__1" c_casadi__DaeBuilder__add_q__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__add_q__1
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__add_q__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_q__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_q__1 :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_add_q__1 x = casadi__DaeBuilder__add_q__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_q__2" c_casadi__DaeBuilder__add_q__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__DaeBuilder__add_q__2
-  :: DaeBuilder -> String -> Int -> IO MX
-casadi__DaeBuilder__add_q__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_q__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_q__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
-daeBuilder_add_q__2 x = casadi__DaeBuilder__add_q__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_quad__0" c_casadi__DaeBuilder__add_quad__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
-casadi__DaeBuilder__add_quad__0
-  :: DaeBuilder -> MX -> IO ()
-casadi__DaeBuilder__add_quad__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_quad__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_quad__0 :: DaeBuilderClass a => a -> MX -> IO ()
-daeBuilder_add_quad__0 x = casadi__DaeBuilder__add_quad__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_quad__1" c_casadi__DaeBuilder__add_quad__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
-casadi__DaeBuilder__add_quad__1
-  :: DaeBuilder -> MX -> String -> IO ()
-casadi__DaeBuilder__add_quad__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_quad__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_quad__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
-daeBuilder_add_quad__1 x = casadi__DaeBuilder__add_quad__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_s__0" c_casadi__DaeBuilder__add_s__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr (StdPair (Ptr MX') (Ptr MX')))
-casadi__DaeBuilder__add_s__0
-  :: DaeBuilder -> IO (MX, MX)
-casadi__DaeBuilder__add_s__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_s__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_s__0 :: DaeBuilderClass a => a -> IO (MX, MX)
-daeBuilder_add_s__0 x = casadi__DaeBuilder__add_s__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_s__1" c_casadi__DaeBuilder__add_s__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr (StdPair (Ptr MX') (Ptr MX')))
-casadi__DaeBuilder__add_s__1
-  :: DaeBuilder -> String -> IO (MX, MX)
-casadi__DaeBuilder__add_s__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_s__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_s__1 :: DaeBuilderClass a => a -> String -> IO (MX, MX)
-daeBuilder_add_s__1 x = casadi__DaeBuilder__add_s__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_s__2" c_casadi__DaeBuilder__add_s__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr (StdPair (Ptr MX') (Ptr MX')))
-casadi__DaeBuilder__add_s__2
-  :: DaeBuilder -> String -> Int -> IO (MX, MX)
-casadi__DaeBuilder__add_s__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_s__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_s__2 :: DaeBuilderClass a => a -> String -> Int -> IO (MX, MX)
-daeBuilder_add_s__2 x = casadi__DaeBuilder__add_s__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_u__0" c_casadi__DaeBuilder__add_u__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
-casadi__DaeBuilder__add_u__0
-  :: DaeBuilder -> IO MX
-casadi__DaeBuilder__add_u__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_u__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_u__0 :: DaeBuilderClass a => a -> IO MX
-daeBuilder_add_u__0 x = casadi__DaeBuilder__add_u__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_u__1" c_casadi__DaeBuilder__add_u__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__add_u__1
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__add_u__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_u__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_u__1 :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_add_u__1 x = casadi__DaeBuilder__add_u__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_u__2" c_casadi__DaeBuilder__add_u__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__DaeBuilder__add_u__2
-  :: DaeBuilder -> String -> Int -> IO MX
-casadi__DaeBuilder__add_u__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_u__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_u__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
-daeBuilder_add_u__2 x = casadi__DaeBuilder__add_u__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_x__0" c_casadi__DaeBuilder__add_x__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
-casadi__DaeBuilder__add_x__0
-  :: DaeBuilder -> IO MX
-casadi__DaeBuilder__add_x__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_x__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_x__0 :: DaeBuilderClass a => a -> IO MX
-daeBuilder_add_x__0 x = casadi__DaeBuilder__add_x__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_x__1" c_casadi__DaeBuilder__add_x__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__add_x__1
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__add_x__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_x__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_x__1 :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_add_x__1 x = casadi__DaeBuilder__add_x__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_x__2" c_casadi__DaeBuilder__add_x__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__DaeBuilder__add_x__2
-  :: DaeBuilder -> String -> Int -> IO MX
-casadi__DaeBuilder__add_x__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_x__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_x__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
-daeBuilder_add_x__2 x = casadi__DaeBuilder__add_x__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_y__0" c_casadi__DaeBuilder__add_y__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX')
-casadi__DaeBuilder__add_y__0
-  :: DaeBuilder -> MX -> IO MX
-casadi__DaeBuilder__add_y__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_y__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_y__0 :: DaeBuilderClass a => a -> MX -> IO MX
-daeBuilder_add_y__0 x = casadi__DaeBuilder__add_y__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_y__1" c_casadi__DaeBuilder__add_y__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__add_y__1
-  :: DaeBuilder -> MX -> String -> IO MX
-casadi__DaeBuilder__add_y__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_y__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_y__1 :: DaeBuilderClass a => a -> MX -> String -> IO MX
-daeBuilder_add_y__1 x = casadi__DaeBuilder__add_y__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_z__0" c_casadi__DaeBuilder__add_z__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
-casadi__DaeBuilder__add_z__0
-  :: DaeBuilder -> IO MX
-casadi__DaeBuilder__add_z__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_z__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_z__0 :: DaeBuilderClass a => a -> IO MX
-daeBuilder_add_z__0 x = casadi__DaeBuilder__add_z__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_z__1" c_casadi__DaeBuilder__add_z__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__add_z__1
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__add_z__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_z__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_z__1 :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_add_z__1 x = casadi__DaeBuilder__add_z__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__add_z__2" c_casadi__DaeBuilder__add_z__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__DaeBuilder__add_z__2
-  :: DaeBuilder -> String -> Int -> IO MX
-casadi__DaeBuilder__add_z__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__add_z__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_add_z__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
-daeBuilder_add_z__2 x = casadi__DaeBuilder__add_z__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__create" c_casadi__DaeBuilder__create
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr MXFunction')
-casadi__DaeBuilder__create
-  :: DaeBuilder -> String -> Vector String -> Vector String -> IO MXFunction
-casadi__DaeBuilder__create x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__create errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_create :: DaeBuilderClass a => a -> String -> Vector String -> Vector String -> IO MXFunction
-daeBuilder_create x = casadi__DaeBuilder__create (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__der__0" c_casadi__DaeBuilder__der__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX')
-casadi__DaeBuilder__der__0
-  :: DaeBuilder -> MX -> IO MX
-casadi__DaeBuilder__der__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__der__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_der__0 :: DaeBuilderClass a => a -> MX -> IO MX
-daeBuilder_der__0 x = casadi__DaeBuilder__der__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__der__1" c_casadi__DaeBuilder__der__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__der__1
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__der__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__der__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_der__1 :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_der__1 x = casadi__DaeBuilder__der__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__0" c_casadi__DaeBuilder__derivativeStart__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__derivativeStart__0
-  :: DaeBuilder -> MX -> IO (Vector Double)
-casadi__DaeBuilder__derivativeStart__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__derivativeStart__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_derivativeStart__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
-daeBuilder_derivativeStart__0 x = casadi__DaeBuilder__derivativeStart__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__1" c_casadi__DaeBuilder__derivativeStart__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__derivativeStart__1
-  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
-casadi__DaeBuilder__derivativeStart__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__derivativeStart__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_derivativeStart__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
-daeBuilder_derivativeStart__1 x = casadi__DaeBuilder__derivativeStart__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__2" c_casadi__DaeBuilder__derivativeStart__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
-casadi__DaeBuilder__derivativeStart__2
-  :: DaeBuilder -> String -> IO Double
-casadi__DaeBuilder__derivativeStart__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__derivativeStart__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_derivativeStart__2 :: DaeBuilderClass a => a -> String -> IO Double
-daeBuilder_derivativeStart__2 x = casadi__DaeBuilder__derivativeStart__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__3" c_casadi__DaeBuilder__derivativeStart__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
-casadi__DaeBuilder__derivativeStart__3
-  :: DaeBuilder -> String -> Bool -> IO Double
-casadi__DaeBuilder__derivativeStart__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__derivativeStart__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_derivativeStart__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
-daeBuilder_derivativeStart__3 x = casadi__DaeBuilder__derivativeStart__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__eliminate_alg" c_casadi__DaeBuilder__eliminate_alg
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__eliminate_alg
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__eliminate_alg x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__eliminate_alg errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_eliminate_alg :: DaeBuilderClass a => a -> IO ()
-daeBuilder_eliminate_alg x = casadi__DaeBuilder__eliminate_alg (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__eliminate_d" c_casadi__DaeBuilder__eliminate_d
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__eliminate_d
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__eliminate_d x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__eliminate_d errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_eliminate_d :: DaeBuilderClass a => a -> IO ()
-daeBuilder_eliminate_d x = casadi__DaeBuilder__eliminate_d (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__eliminate_quad" c_casadi__DaeBuilder__eliminate_quad
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__eliminate_quad
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__eliminate_quad x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__eliminate_quad errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_eliminate_quad :: DaeBuilderClass a => a -> IO ()
-daeBuilder_eliminate_quad x = casadi__DaeBuilder__eliminate_quad (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__0" c_casadi__DaeBuilder__initialGuess__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__initialGuess__0
-  :: DaeBuilder -> MX -> IO (Vector Double)
-casadi__DaeBuilder__initialGuess__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__initialGuess__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_initialGuess__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
-daeBuilder_initialGuess__0 x = casadi__DaeBuilder__initialGuess__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__1" c_casadi__DaeBuilder__initialGuess__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__initialGuess__1
-  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
-casadi__DaeBuilder__initialGuess__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__initialGuess__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_initialGuess__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
-daeBuilder_initialGuess__1 x = casadi__DaeBuilder__initialGuess__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__2" c_casadi__DaeBuilder__initialGuess__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
-casadi__DaeBuilder__initialGuess__2
-  :: DaeBuilder -> String -> IO Double
-casadi__DaeBuilder__initialGuess__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__initialGuess__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_initialGuess__2 :: DaeBuilderClass a => a -> String -> IO Double
-daeBuilder_initialGuess__2 x = casadi__DaeBuilder__initialGuess__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__3" c_casadi__DaeBuilder__initialGuess__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
-casadi__DaeBuilder__initialGuess__3
-  :: DaeBuilder -> String -> Bool -> IO Double
-casadi__DaeBuilder__initialGuess__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__initialGuess__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_initialGuess__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
-daeBuilder_initialGuess__3 x = casadi__DaeBuilder__initialGuess__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__makeExplicit" c_casadi__DaeBuilder__makeExplicit
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__makeExplicit
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__makeExplicit x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__makeExplicit errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_makeExplicit :: DaeBuilderClass a => a -> IO ()
-daeBuilder_makeExplicit x = casadi__DaeBuilder__makeExplicit (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__makeSemiExplicit" c_casadi__DaeBuilder__makeSemiExplicit
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__makeSemiExplicit
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__makeSemiExplicit x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__makeSemiExplicit errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_makeSemiExplicit :: DaeBuilderClass a => a -> IO ()
-daeBuilder_makeSemiExplicit x = casadi__DaeBuilder__makeSemiExplicit (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__max__0" c_casadi__DaeBuilder__max__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__max__0
-  :: DaeBuilder -> MX -> IO (Vector Double)
-casadi__DaeBuilder__max__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__max__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_max__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
-daeBuilder_max__0 x = casadi__DaeBuilder__max__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__max__1" c_casadi__DaeBuilder__max__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__max__1
-  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
-casadi__DaeBuilder__max__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__max__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_max__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
-daeBuilder_max__1 x = casadi__DaeBuilder__max__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__max__2" c_casadi__DaeBuilder__max__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
-casadi__DaeBuilder__max__2
-  :: DaeBuilder -> String -> IO Double
-casadi__DaeBuilder__max__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__max__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_max__2 :: DaeBuilderClass a => a -> String -> IO Double
-daeBuilder_max__2 x = casadi__DaeBuilder__max__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__max__3" c_casadi__DaeBuilder__max__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
-casadi__DaeBuilder__max__3
-  :: DaeBuilder -> String -> Bool -> IO Double
-casadi__DaeBuilder__max__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__max__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_max__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
-daeBuilder_max__3 x = casadi__DaeBuilder__max__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__min__0" c_casadi__DaeBuilder__min__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__min__0
-  :: DaeBuilder -> MX -> IO (Vector Double)
-casadi__DaeBuilder__min__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__min__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_min__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
-daeBuilder_min__0 x = casadi__DaeBuilder__min__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__min__1" c_casadi__DaeBuilder__min__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__min__1
-  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
-casadi__DaeBuilder__min__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__min__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_min__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
-daeBuilder_min__1 x = casadi__DaeBuilder__min__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__min__2" c_casadi__DaeBuilder__min__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
-casadi__DaeBuilder__min__2
-  :: DaeBuilder -> String -> IO Double
-casadi__DaeBuilder__min__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__min__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_min__2 :: DaeBuilderClass a => a -> String -> IO Double
-daeBuilder_min__2 x = casadi__DaeBuilder__min__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__min__3" c_casadi__DaeBuilder__min__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
-casadi__DaeBuilder__min__3
-  :: DaeBuilder -> String -> Bool -> IO Double
-casadi__DaeBuilder__min__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__min__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_min__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
-daeBuilder_min__3 x = casadi__DaeBuilder__min__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__nominal__0" c_casadi__DaeBuilder__nominal__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__nominal__0
-  :: DaeBuilder -> MX -> IO (Vector Double)
-casadi__DaeBuilder__nominal__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__nominal__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_nominal__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
-daeBuilder_nominal__0 x = casadi__DaeBuilder__nominal__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__nominal__1" c_casadi__DaeBuilder__nominal__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
-casadi__DaeBuilder__nominal__1
-  :: DaeBuilder -> String -> IO Double
-casadi__DaeBuilder__nominal__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__nominal__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_nominal__1 :: DaeBuilderClass a => a -> String -> IO Double
-daeBuilder_nominal__1 x = casadi__DaeBuilder__nominal__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__operator_call" c_casadi__DaeBuilder__operator_call
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
-casadi__DaeBuilder__operator_call
-  :: DaeBuilder -> String -> IO MX
-casadi__DaeBuilder__operator_call x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__operator_call errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_operator_call :: DaeBuilderClass a => a -> String -> IO MX
-daeBuilder_operator_call x = casadi__DaeBuilder__operator_call (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__parseFMI" c_casadi__DaeBuilder__parseFMI
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO ()
-casadi__DaeBuilder__parseFMI
-  :: DaeBuilder -> String -> IO ()
-casadi__DaeBuilder__parseFMI x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__parseFMI errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_parseFMI :: DaeBuilderClass a => a -> String -> IO ()
-daeBuilder_parseFMI x = casadi__DaeBuilder__parseFMI (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__sanityCheck" c_casadi__DaeBuilder__sanityCheck
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__sanityCheck
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__sanityCheck x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__sanityCheck errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_sanityCheck :: DaeBuilderClass a => a -> IO ()
-daeBuilder_sanityCheck x = casadi__DaeBuilder__sanityCheck (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__scaleEquations" c_casadi__DaeBuilder__scaleEquations
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__scaleEquations
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__scaleEquations x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__scaleEquations errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_scaleEquations :: DaeBuilderClass a => a -> IO ()
-daeBuilder_scaleEquations x = casadi__DaeBuilder__scaleEquations (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__scaleVariables" c_casadi__DaeBuilder__scaleVariables
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__scaleVariables
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__scaleVariables x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__scaleVariables errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_scaleVariables :: DaeBuilderClass a => a -> IO ()
-daeBuilder_scaleVariables x = casadi__DaeBuilder__scaleVariables (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__0" c_casadi__DaeBuilder__setDerivativeStart__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DaeBuilder__setDerivativeStart__0
-  :: DaeBuilder -> MX -> Vector Double -> IO ()
-casadi__DaeBuilder__setDerivativeStart__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setDerivativeStart__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setDerivativeStart__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
-daeBuilder_setDerivativeStart__0 x = casadi__DaeBuilder__setDerivativeStart__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__1" c_casadi__DaeBuilder__setDerivativeStart__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__DaeBuilder__setDerivativeStart__1
-  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
-casadi__DaeBuilder__setDerivativeStart__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setDerivativeStart__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setDerivativeStart__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
-daeBuilder_setDerivativeStart__1 x = casadi__DaeBuilder__setDerivativeStart__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__2" c_casadi__DaeBuilder__setDerivativeStart__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
-casadi__DaeBuilder__setDerivativeStart__2
-  :: DaeBuilder -> String -> Double -> IO ()
-casadi__DaeBuilder__setDerivativeStart__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setDerivativeStart__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setDerivativeStart__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
-daeBuilder_setDerivativeStart__2 x = casadi__DaeBuilder__setDerivativeStart__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__3" c_casadi__DaeBuilder__setDerivativeStart__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
-casadi__DaeBuilder__setDerivativeStart__3
-  :: DaeBuilder -> String -> Double -> Bool -> IO ()
-casadi__DaeBuilder__setDerivativeStart__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setDerivativeStart__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setDerivativeStart__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
-daeBuilder_setDerivativeStart__3 x = casadi__DaeBuilder__setDerivativeStart__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__0" c_casadi__DaeBuilder__setInitialGuess__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DaeBuilder__setInitialGuess__0
-  :: DaeBuilder -> MX -> Vector Double -> IO ()
-casadi__DaeBuilder__setInitialGuess__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setInitialGuess__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setInitialGuess__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
-daeBuilder_setInitialGuess__0 x = casadi__DaeBuilder__setInitialGuess__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__1" c_casadi__DaeBuilder__setInitialGuess__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__DaeBuilder__setInitialGuess__1
-  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
-casadi__DaeBuilder__setInitialGuess__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setInitialGuess__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setInitialGuess__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
-daeBuilder_setInitialGuess__1 x = casadi__DaeBuilder__setInitialGuess__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__2" c_casadi__DaeBuilder__setInitialGuess__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
-casadi__DaeBuilder__setInitialGuess__2
-  :: DaeBuilder -> String -> Double -> IO ()
-casadi__DaeBuilder__setInitialGuess__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setInitialGuess__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setInitialGuess__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
-daeBuilder_setInitialGuess__2 x = casadi__DaeBuilder__setInitialGuess__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__3" c_casadi__DaeBuilder__setInitialGuess__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
-casadi__DaeBuilder__setInitialGuess__3
-  :: DaeBuilder -> String -> Double -> Bool -> IO ()
-casadi__DaeBuilder__setInitialGuess__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setInitialGuess__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setInitialGuess__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
-daeBuilder_setInitialGuess__3 x = casadi__DaeBuilder__setInitialGuess__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMax__0" c_casadi__DaeBuilder__setMax__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DaeBuilder__setMax__0
-  :: DaeBuilder -> MX -> Vector Double -> IO ()
-casadi__DaeBuilder__setMax__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMax__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMax__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
-daeBuilder_setMax__0 x = casadi__DaeBuilder__setMax__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMax__1" c_casadi__DaeBuilder__setMax__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__DaeBuilder__setMax__1
-  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
-casadi__DaeBuilder__setMax__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMax__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMax__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
-daeBuilder_setMax__1 x = casadi__DaeBuilder__setMax__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMax__2" c_casadi__DaeBuilder__setMax__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
-casadi__DaeBuilder__setMax__2
-  :: DaeBuilder -> String -> Double -> IO ()
-casadi__DaeBuilder__setMax__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMax__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMax__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
-daeBuilder_setMax__2 x = casadi__DaeBuilder__setMax__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMax__3" c_casadi__DaeBuilder__setMax__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
-casadi__DaeBuilder__setMax__3
-  :: DaeBuilder -> String -> Double -> Bool -> IO ()
-casadi__DaeBuilder__setMax__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMax__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMax__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
-daeBuilder_setMax__3 x = casadi__DaeBuilder__setMax__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMin__0" c_casadi__DaeBuilder__setMin__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DaeBuilder__setMin__0
-  :: DaeBuilder -> MX -> Vector Double -> IO ()
-casadi__DaeBuilder__setMin__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMin__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMin__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
-daeBuilder_setMin__0 x = casadi__DaeBuilder__setMin__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMin__1" c_casadi__DaeBuilder__setMin__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__DaeBuilder__setMin__1
-  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
-casadi__DaeBuilder__setMin__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMin__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMin__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
-daeBuilder_setMin__1 x = casadi__DaeBuilder__setMin__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMin__2" c_casadi__DaeBuilder__setMin__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
-casadi__DaeBuilder__setMin__2
-  :: DaeBuilder -> String -> Double -> IO ()
-casadi__DaeBuilder__setMin__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMin__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMin__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
-daeBuilder_setMin__2 x = casadi__DaeBuilder__setMin__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setMin__3" c_casadi__DaeBuilder__setMin__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
-casadi__DaeBuilder__setMin__3
-  :: DaeBuilder -> String -> Double -> Bool -> IO ()
-casadi__DaeBuilder__setMin__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setMin__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setMin__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
-daeBuilder_setMin__3 x = casadi__DaeBuilder__setMin__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setNominal__0" c_casadi__DaeBuilder__setNominal__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DaeBuilder__setNominal__0
-  :: DaeBuilder -> MX -> Vector Double -> IO ()
-casadi__DaeBuilder__setNominal__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setNominal__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setNominal__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
-daeBuilder_setNominal__0 x = casadi__DaeBuilder__setNominal__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setNominal__1" c_casadi__DaeBuilder__setNominal__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
-casadi__DaeBuilder__setNominal__1
-  :: DaeBuilder -> String -> Double -> IO ()
-casadi__DaeBuilder__setNominal__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setNominal__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setNominal__1 :: DaeBuilderClass a => a -> String -> Double -> IO ()
-daeBuilder_setNominal__1 x = casadi__DaeBuilder__setNominal__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setStart__0" c_casadi__DaeBuilder__setStart__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__DaeBuilder__setStart__0
-  :: DaeBuilder -> MX -> Vector Double -> IO ()
-casadi__DaeBuilder__setStart__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setStart__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setStart__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
-daeBuilder_setStart__0 x = casadi__DaeBuilder__setStart__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setStart__1" c_casadi__DaeBuilder__setStart__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__DaeBuilder__setStart__1
-  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
-casadi__DaeBuilder__setStart__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setStart__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setStart__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
-daeBuilder_setStart__1 x = casadi__DaeBuilder__setStart__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setStart__2" c_casadi__DaeBuilder__setStart__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
-casadi__DaeBuilder__setStart__2
-  :: DaeBuilder -> String -> Double -> IO ()
-casadi__DaeBuilder__setStart__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setStart__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setStart__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
-daeBuilder_setStart__2 x = casadi__DaeBuilder__setStart__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setStart__3" c_casadi__DaeBuilder__setStart__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
-casadi__DaeBuilder__setStart__3
-  :: DaeBuilder -> String -> Double -> Bool -> IO ()
-casadi__DaeBuilder__setStart__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setStart__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setStart__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
-daeBuilder_setStart__3 x = casadi__DaeBuilder__setStart__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__setUnit" c_casadi__DaeBuilder__setUnit
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr StdString -> IO ()
-casadi__DaeBuilder__setUnit
-  :: DaeBuilder -> String -> String -> IO ()
-casadi__DaeBuilder__setUnit x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__setUnit errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_setUnit :: DaeBuilderClass a => a -> String -> String -> IO ()
-daeBuilder_setUnit x = casadi__DaeBuilder__setUnit (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__sort_alg" c_casadi__DaeBuilder__sort_alg
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__sort_alg
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__sort_alg x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__sort_alg errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_sort_alg :: DaeBuilderClass a => a -> IO ()
-daeBuilder_sort_alg x = casadi__DaeBuilder__sort_alg (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__sort_d" c_casadi__DaeBuilder__sort_d
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__sort_d
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__sort_d x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__sort_d errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_sort_d :: DaeBuilderClass a => a -> IO ()
-daeBuilder_sort_d x = casadi__DaeBuilder__sort_d (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__sort_dae" c_casadi__DaeBuilder__sort_dae
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__sort_dae
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__sort_dae x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__sort_dae errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_sort_dae :: DaeBuilderClass a => a -> IO ()
-daeBuilder_sort_dae x = casadi__DaeBuilder__sort_dae (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__split_d" c_casadi__DaeBuilder__split_d
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__split_d
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__split_d x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__split_d errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_split_d :: DaeBuilderClass a => a -> IO ()
-daeBuilder_split_d x = casadi__DaeBuilder__split_d (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__split_dae" c_casadi__DaeBuilder__split_dae
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
-casadi__DaeBuilder__split_dae
-  :: DaeBuilder -> IO ()
-casadi__DaeBuilder__split_dae x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__split_dae errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_split_dae :: DaeBuilderClass a => a -> IO ()
-daeBuilder_split_dae x = casadi__DaeBuilder__split_dae (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__start__0" c_casadi__DaeBuilder__start__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__start__0
-  :: DaeBuilder -> MX -> IO (Vector Double)
-casadi__DaeBuilder__start__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__start__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_start__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
-daeBuilder_start__0 x = casadi__DaeBuilder__start__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__start__1" c_casadi__DaeBuilder__start__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
-casadi__DaeBuilder__start__1
-  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
-casadi__DaeBuilder__start__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__start__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_start__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
-daeBuilder_start__1 x = casadi__DaeBuilder__start__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__start__2" c_casadi__DaeBuilder__start__2
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
-casadi__DaeBuilder__start__2
-  :: DaeBuilder -> String -> IO Double
-casadi__DaeBuilder__start__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__start__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_start__2 :: DaeBuilderClass a => a -> String -> IO Double
-daeBuilder_start__2 x = casadi__DaeBuilder__start__2 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__start__3" c_casadi__DaeBuilder__start__3
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
-casadi__DaeBuilder__start__3
-  :: DaeBuilder -> String -> Bool -> IO Double
-casadi__DaeBuilder__start__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__start__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_start__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
-daeBuilder_start__3 x = casadi__DaeBuilder__start__3 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__unit__0" c_casadi__DaeBuilder__unit__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr StdString)
-casadi__DaeBuilder__unit__0
-  :: DaeBuilder -> MX -> IO String
-casadi__DaeBuilder__unit__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__unit__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_unit__0 :: DaeBuilderClass a => a -> MX -> IO String
-daeBuilder_unit__0 x = casadi__DaeBuilder__unit__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__unit__1" c_casadi__DaeBuilder__unit__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr StdString)
-casadi__DaeBuilder__unit__1
-  :: DaeBuilder -> String -> IO String
-casadi__DaeBuilder__unit__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__unit__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_unit__1 :: DaeBuilderClass a => a -> String -> IO String
-daeBuilder_unit__1 x = casadi__DaeBuilder__unit__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__variable__0" c_casadi__DaeBuilder__variable__0
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr Variable')
-casadi__DaeBuilder__variable__0
-  :: DaeBuilder -> String -> IO Variable
-casadi__DaeBuilder__variable__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__variable__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_variable__0 :: DaeBuilderClass a => a -> String -> IO Variable
-daeBuilder_variable__0 x = casadi__DaeBuilder__variable__0 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__variable__1" c_casadi__DaeBuilder__variable__1
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr Variable')
-casadi__DaeBuilder__variable__1
-  :: DaeBuilder -> String -> IO Variable
-casadi__DaeBuilder__variable__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__variable__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_variable__1 :: DaeBuilderClass a => a -> String -> IO Variable
-daeBuilder_variable__1 x = casadi__DaeBuilder__variable__1 (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__getRepresentation" c_casadi__DaeBuilder__getRepresentation
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr StdString)
-casadi__DaeBuilder__getRepresentation
-  :: DaeBuilder -> IO String
-casadi__DaeBuilder__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-daeBuilder_getRepresentation :: DaeBuilderClass a => a -> IO String
-daeBuilder_getRepresentation x = casadi__DaeBuilder__getRepresentation (castDaeBuilder x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DaeBuilder__getDescription" c_casadi__DaeBuilder__getDescription
-  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr StdString)
-casadi__DaeBuilder__getDescription
-  :: DaeBuilder -> IO String
-casadi__DaeBuilder__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DaeBuilder__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+         daeBuilder_add_alg__0,
+         daeBuilder_add_alg__1,
+         daeBuilder_add_d__0,
+         daeBuilder_add_d__1,
+         daeBuilder_add_dae__0,
+         daeBuilder_add_dae__1,
+         daeBuilder_add_lc,
+         daeBuilder_add_ode__0,
+         daeBuilder_add_ode__1,
+         daeBuilder_add_p__0,
+         daeBuilder_add_p__1,
+         daeBuilder_add_p__2,
+         daeBuilder_add_q__0,
+         daeBuilder_add_q__1,
+         daeBuilder_add_q__2,
+         daeBuilder_add_quad__0,
+         daeBuilder_add_quad__1,
+         daeBuilder_add_s__0,
+         daeBuilder_add_s__1,
+         daeBuilder_add_s__2,
+         daeBuilder_add_u__0,
+         daeBuilder_add_u__1,
+         daeBuilder_add_u__2,
+         daeBuilder_add_variable__0,
+         daeBuilder_add_variable__1,
+         daeBuilder_add_variable__2,
+         daeBuilder_add_variable__3,
+         daeBuilder_add_x__0,
+         daeBuilder_add_x__1,
+         daeBuilder_add_x__2,
+         daeBuilder_add_y__0,
+         daeBuilder_add_y__1,
+         daeBuilder_add_z__0,
+         daeBuilder_add_z__1,
+         daeBuilder_add_z__2,
+         daeBuilder_create,
+         daeBuilder_der__0,
+         daeBuilder_der__1,
+         daeBuilder_derivative_start__0,
+         daeBuilder_derivative_start__1,
+         daeBuilder_derivative_start__2,
+         daeBuilder_derivative_start__3,
+         daeBuilder_eliminate_alg,
+         daeBuilder_eliminate_d,
+         daeBuilder_eliminate_quad,
+         daeBuilder_getDescription,
+         daeBuilder_getRepresentation,
+         daeBuilder_guess__0,
+         daeBuilder_guess__1,
+         daeBuilder_guess__2,
+         daeBuilder_guess__3,
+         daeBuilder_make_explicit,
+         daeBuilder_make_semi_explicit,
+         daeBuilder_max__0,
+         daeBuilder_max__1,
+         daeBuilder_max__2,
+         daeBuilder_max__3,
+         daeBuilder_min__0,
+         daeBuilder_min__1,
+         daeBuilder_min__2,
+         daeBuilder_min__3,
+         daeBuilder_nominal__0,
+         daeBuilder_nominal__1,
+         daeBuilder_operator__call,
+         daeBuilder_parse_fmi,
+         daeBuilder_sanity_check,
+         daeBuilder_scale_equations,
+         daeBuilder_scale_variables,
+         daeBuilder_set_derivative_start__0,
+         daeBuilder_set_derivative_start__1,
+         daeBuilder_set_derivative_start__2,
+         daeBuilder_set_derivative_start__3,
+         daeBuilder_set_guess__0,
+         daeBuilder_set_guess__1,
+         daeBuilder_set_guess__2,
+         daeBuilder_set_guess__3,
+         daeBuilder_set_max__0,
+         daeBuilder_set_max__1,
+         daeBuilder_set_max__2,
+         daeBuilder_set_max__3,
+         daeBuilder_set_min__0,
+         daeBuilder_set_min__1,
+         daeBuilder_set_min__2,
+         daeBuilder_set_min__3,
+         daeBuilder_set_nominal__0,
+         daeBuilder_set_nominal__1,
+         daeBuilder_set_start__0,
+         daeBuilder_set_start__1,
+         daeBuilder_set_start__2,
+         daeBuilder_set_start__3,
+         daeBuilder_set_unit,
+         daeBuilder_sort_alg,
+         daeBuilder_sort_d,
+         daeBuilder_sort_dae,
+         daeBuilder_split_d,
+         daeBuilder_split_dae,
+         daeBuilder_start__0,
+         daeBuilder_start__1,
+         daeBuilder_start__2,
+         daeBuilder_start__3,
+         daeBuilder_unit__0,
+         daeBuilder_unit__1,
+         daeBuilder_variable__0,
+         daeBuilder_variable__1,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__CONSTRUCTOR" c_casadi__DaeBuilder__CONSTRUCTOR
+  :: Ptr (Ptr StdString) -> IO (Ptr DaeBuilder')
+
+casadi__DaeBuilder__CONSTRUCTOR
+  :: IO DaeBuilder
+casadi__DaeBuilder__CONSTRUCTOR  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__CONSTRUCTOR errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder :: IO DaeBuilder
+daeBuilder = casadi__DaeBuilder__CONSTRUCTOR
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_alg__0" c_casadi__DaeBuilder__add_alg__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
+
+casadi__DaeBuilder__add_alg__0
+  :: DaeBuilder -> MX -> IO ()
+casadi__DaeBuilder__add_alg__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_alg__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_alg__0 :: DaeBuilderClass a => a -> MX -> IO ()
+daeBuilder_add_alg__0 x = casadi__DaeBuilder__add_alg__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_alg__1" c_casadi__DaeBuilder__add_alg__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
+
+casadi__DaeBuilder__add_alg__1
+  :: DaeBuilder -> MX -> String -> IO ()
+casadi__DaeBuilder__add_alg__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_alg__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_alg__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
+daeBuilder_add_alg__1 x = casadi__DaeBuilder__add_alg__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_d__0" c_casadi__DaeBuilder__add_d__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_d__0
+  :: DaeBuilder -> MX -> IO MX
+casadi__DaeBuilder__add_d__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_d__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_d__0 :: DaeBuilderClass a => a -> MX -> IO MX
+daeBuilder_add_d__0 x = casadi__DaeBuilder__add_d__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_d__1" c_casadi__DaeBuilder__add_d__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_d__1
+  :: DaeBuilder -> MX -> String -> IO MX
+casadi__DaeBuilder__add_d__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_d__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_d__1 :: DaeBuilderClass a => a -> MX -> String -> IO MX
+daeBuilder_add_d__1 x = casadi__DaeBuilder__add_d__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_dae__0" c_casadi__DaeBuilder__add_dae__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
+
+casadi__DaeBuilder__add_dae__0
+  :: DaeBuilder -> MX -> IO ()
+casadi__DaeBuilder__add_dae__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_dae__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_dae__0 :: DaeBuilderClass a => a -> MX -> IO ()
+daeBuilder_add_dae__0 x = casadi__DaeBuilder__add_dae__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_dae__1" c_casadi__DaeBuilder__add_dae__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
+
+casadi__DaeBuilder__add_dae__1
+  :: DaeBuilder -> MX -> String -> IO ()
+casadi__DaeBuilder__add_dae__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_dae__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_dae__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
+daeBuilder_add_dae__1 x = casadi__DaeBuilder__add_dae__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_lc" c_casadi__DaeBuilder__add_lc
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_lc
+  :: DaeBuilder -> String -> Vector String -> IO MX
+casadi__DaeBuilder__add_lc x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_lc errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_lc :: DaeBuilderClass a => a -> String -> Vector String -> IO MX
+daeBuilder_add_lc x = casadi__DaeBuilder__add_lc (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_ode__0" c_casadi__DaeBuilder__add_ode__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
+
+casadi__DaeBuilder__add_ode__0
+  :: DaeBuilder -> MX -> IO ()
+casadi__DaeBuilder__add_ode__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_ode__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_ode__0 :: DaeBuilderClass a => a -> MX -> IO ()
+daeBuilder_add_ode__0 x = casadi__DaeBuilder__add_ode__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_ode__1" c_casadi__DaeBuilder__add_ode__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
+
+casadi__DaeBuilder__add_ode__1
+  :: DaeBuilder -> MX -> String -> IO ()
+casadi__DaeBuilder__add_ode__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_ode__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_ode__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
+daeBuilder_add_ode__1 x = casadi__DaeBuilder__add_ode__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_p__0" c_casadi__DaeBuilder__add_p__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_p__0
+  :: DaeBuilder -> IO MX
+casadi__DaeBuilder__add_p__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_p__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_p__0 :: DaeBuilderClass a => a -> IO MX
+daeBuilder_add_p__0 x = casadi__DaeBuilder__add_p__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_p__1" c_casadi__DaeBuilder__add_p__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_p__1
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__add_p__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_p__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_p__1 :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_add_p__1 x = casadi__DaeBuilder__add_p__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_p__2" c_casadi__DaeBuilder__add_p__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_p__2
+  :: DaeBuilder -> String -> Int -> IO MX
+casadi__DaeBuilder__add_p__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_p__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_p__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
+daeBuilder_add_p__2 x = casadi__DaeBuilder__add_p__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_q__0" c_casadi__DaeBuilder__add_q__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_q__0
+  :: DaeBuilder -> IO MX
+casadi__DaeBuilder__add_q__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_q__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_q__0 :: DaeBuilderClass a => a -> IO MX
+daeBuilder_add_q__0 x = casadi__DaeBuilder__add_q__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_q__1" c_casadi__DaeBuilder__add_q__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_q__1
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__add_q__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_q__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_q__1 :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_add_q__1 x = casadi__DaeBuilder__add_q__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_q__2" c_casadi__DaeBuilder__add_q__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_q__2
+  :: DaeBuilder -> String -> Int -> IO MX
+casadi__DaeBuilder__add_q__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_q__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_q__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
+daeBuilder_add_q__2 x = casadi__DaeBuilder__add_q__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_quad__0" c_casadi__DaeBuilder__add_quad__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO ()
+
+casadi__DaeBuilder__add_quad__0
+  :: DaeBuilder -> MX -> IO ()
+casadi__DaeBuilder__add_quad__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_quad__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_quad__0 :: DaeBuilderClass a => a -> MX -> IO ()
+daeBuilder_add_quad__0 x = casadi__DaeBuilder__add_quad__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_quad__1" c_casadi__DaeBuilder__add_quad__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO ()
+
+casadi__DaeBuilder__add_quad__1
+  :: DaeBuilder -> MX -> String -> IO ()
+casadi__DaeBuilder__add_quad__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_quad__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_quad__1 :: DaeBuilderClass a => a -> MX -> String -> IO ()
+daeBuilder_add_quad__1 x = casadi__DaeBuilder__add_quad__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_s__0" c_casadi__DaeBuilder__add_s__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr (StdPair (Ptr MX') (Ptr MX')))
+
+casadi__DaeBuilder__add_s__0
+  :: DaeBuilder -> IO (MX, MX)
+casadi__DaeBuilder__add_s__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_s__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_s__0 :: DaeBuilderClass a => a -> IO (MX, MX)
+daeBuilder_add_s__0 x = casadi__DaeBuilder__add_s__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_s__1" c_casadi__DaeBuilder__add_s__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr (StdPair (Ptr MX') (Ptr MX')))
+
+casadi__DaeBuilder__add_s__1
+  :: DaeBuilder -> String -> IO (MX, MX)
+casadi__DaeBuilder__add_s__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_s__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_s__1 :: DaeBuilderClass a => a -> String -> IO (MX, MX)
+daeBuilder_add_s__1 x = casadi__DaeBuilder__add_s__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_s__2" c_casadi__DaeBuilder__add_s__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr (StdPair (Ptr MX') (Ptr MX')))
+
+casadi__DaeBuilder__add_s__2
+  :: DaeBuilder -> String -> Int -> IO (MX, MX)
+casadi__DaeBuilder__add_s__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_s__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_s__2 :: DaeBuilderClass a => a -> String -> Int -> IO (MX, MX)
+daeBuilder_add_s__2 x = casadi__DaeBuilder__add_s__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_u__0" c_casadi__DaeBuilder__add_u__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_u__0
+  :: DaeBuilder -> IO MX
+casadi__DaeBuilder__add_u__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_u__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_u__0 :: DaeBuilderClass a => a -> IO MX
+daeBuilder_add_u__0 x = casadi__DaeBuilder__add_u__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_u__1" c_casadi__DaeBuilder__add_u__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_u__1
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__add_u__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_u__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_u__1 :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_add_u__1 x = casadi__DaeBuilder__add_u__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_u__2" c_casadi__DaeBuilder__add_u__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_u__2
+  :: DaeBuilder -> String -> Int -> IO MX
+casadi__DaeBuilder__add_u__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_u__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_u__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
+daeBuilder_add_u__2 x = casadi__DaeBuilder__add_u__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_variable__0" c_casadi__DaeBuilder__add_variable__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_variable__0
+  :: DaeBuilder -> String -> Sparsity -> IO MX
+casadi__DaeBuilder__add_variable__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_variable__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_variable__0 :: DaeBuilderClass a => a -> String -> Sparsity -> IO MX
+daeBuilder_add_variable__0 x = casadi__DaeBuilder__add_variable__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_variable__1" c_casadi__DaeBuilder__add_variable__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_variable__1
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__add_variable__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_variable__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_variable__1 :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_add_variable__1 x = casadi__DaeBuilder__add_variable__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_variable__2" c_casadi__DaeBuilder__add_variable__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_variable__2
+  :: DaeBuilder -> String -> Int -> IO MX
+casadi__DaeBuilder__add_variable__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_variable__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_variable__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
+daeBuilder_add_variable__2 x = casadi__DaeBuilder__add_variable__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_variable__3" c_casadi__DaeBuilder__add_variable__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr Variable' -> IO ()
+
+casadi__DaeBuilder__add_variable__3
+  :: DaeBuilder -> String -> Variable -> IO ()
+casadi__DaeBuilder__add_variable__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_variable__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_add_variable__3 :: DaeBuilderClass a => a -> String -> Variable -> IO ()
+daeBuilder_add_variable__3 x = casadi__DaeBuilder__add_variable__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_x__0" c_casadi__DaeBuilder__add_x__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_x__0
+  :: DaeBuilder -> IO MX
+casadi__DaeBuilder__add_x__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_x__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_x__0 :: DaeBuilderClass a => a -> IO MX
+daeBuilder_add_x__0 x = casadi__DaeBuilder__add_x__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_x__1" c_casadi__DaeBuilder__add_x__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_x__1
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__add_x__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_x__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_x__1 :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_add_x__1 x = casadi__DaeBuilder__add_x__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_x__2" c_casadi__DaeBuilder__add_x__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_x__2
+  :: DaeBuilder -> String -> Int -> IO MX
+casadi__DaeBuilder__add_x__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_x__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_x__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
+daeBuilder_add_x__2 x = casadi__DaeBuilder__add_x__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_y__0" c_casadi__DaeBuilder__add_y__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_y__0
+  :: DaeBuilder -> MX -> IO MX
+casadi__DaeBuilder__add_y__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_y__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_y__0 :: DaeBuilderClass a => a -> MX -> IO MX
+daeBuilder_add_y__0 x = casadi__DaeBuilder__add_y__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_y__1" c_casadi__DaeBuilder__add_y__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_y__1
+  :: DaeBuilder -> MX -> String -> IO MX
+casadi__DaeBuilder__add_y__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_y__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_y__1 :: DaeBuilderClass a => a -> MX -> String -> IO MX
+daeBuilder_add_y__1 x = casadi__DaeBuilder__add_y__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_z__0" c_casadi__DaeBuilder__add_z__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_z__0
+  :: DaeBuilder -> IO MX
+casadi__DaeBuilder__add_z__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_z__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_z__0 :: DaeBuilderClass a => a -> IO MX
+daeBuilder_add_z__0 x = casadi__DaeBuilder__add_z__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_z__1" c_casadi__DaeBuilder__add_z__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_z__1
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__add_z__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_z__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_z__1 :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_add_z__1 x = casadi__DaeBuilder__add_z__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__add_z__2" c_casadi__DaeBuilder__add_z__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__DaeBuilder__add_z__2
+  :: DaeBuilder -> String -> Int -> IO MX
+casadi__DaeBuilder__add_z__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__add_z__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_add_z__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX
+daeBuilder_add_z__2 x = casadi__DaeBuilder__add_z__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__create" c_casadi__DaeBuilder__create
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr Function')
+
+casadi__DaeBuilder__create
+  :: DaeBuilder -> String -> Vector String -> Vector String -> IO Function
+casadi__DaeBuilder__create x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__create errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_create :: DaeBuilderClass a => a -> String -> Vector String -> Vector String -> IO Function
+daeBuilder_create x = casadi__DaeBuilder__create (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__der__0" c_casadi__DaeBuilder__der__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__DaeBuilder__der__0
+  :: DaeBuilder -> MX -> IO MX
+casadi__DaeBuilder__der__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__der__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_der__0 :: DaeBuilderClass a => a -> MX -> IO MX
+daeBuilder_der__0 x = casadi__DaeBuilder__der__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__der__1" c_casadi__DaeBuilder__der__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__der__1
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__der__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__der__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_der__1 :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_der__1 x = casadi__DaeBuilder__der__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__derivative_start__0" c_casadi__DaeBuilder__derivative_start__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__derivative_start__0
+  :: DaeBuilder -> MX -> IO (Vector Double)
+casadi__DaeBuilder__derivative_start__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__derivative_start__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_derivative_start__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
+daeBuilder_derivative_start__0 x = casadi__DaeBuilder__derivative_start__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__derivative_start__1" c_casadi__DaeBuilder__derivative_start__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__derivative_start__1
+  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
+casadi__DaeBuilder__derivative_start__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__derivative_start__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_derivative_start__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
+daeBuilder_derivative_start__1 x = casadi__DaeBuilder__derivative_start__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__derivative_start__2" c_casadi__DaeBuilder__derivative_start__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
+
+casadi__DaeBuilder__derivative_start__2
+  :: DaeBuilder -> String -> IO Double
+casadi__DaeBuilder__derivative_start__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__derivative_start__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_derivative_start__2 :: DaeBuilderClass a => a -> String -> IO Double
+daeBuilder_derivative_start__2 x = casadi__DaeBuilder__derivative_start__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__derivative_start__3" c_casadi__DaeBuilder__derivative_start__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
+
+casadi__DaeBuilder__derivative_start__3
+  :: DaeBuilder -> String -> Bool -> IO Double
+casadi__DaeBuilder__derivative_start__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__derivative_start__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_derivative_start__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
+daeBuilder_derivative_start__3 x = casadi__DaeBuilder__derivative_start__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__eliminate_alg" c_casadi__DaeBuilder__eliminate_alg
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__eliminate_alg
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__eliminate_alg x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__eliminate_alg errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_eliminate_alg :: DaeBuilderClass a => a -> IO ()
+daeBuilder_eliminate_alg x = casadi__DaeBuilder__eliminate_alg (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__eliminate_d" c_casadi__DaeBuilder__eliminate_d
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__eliminate_d
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__eliminate_d x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__eliminate_d errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_eliminate_d :: DaeBuilderClass a => a -> IO ()
+daeBuilder_eliminate_d x = casadi__DaeBuilder__eliminate_d (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__eliminate_quad" c_casadi__DaeBuilder__eliminate_quad
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__eliminate_quad
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__eliminate_quad x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__eliminate_quad errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_eliminate_quad :: DaeBuilderClass a => a -> IO ()
+daeBuilder_eliminate_quad x = casadi__DaeBuilder__eliminate_quad (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__guess__0" c_casadi__DaeBuilder__guess__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__guess__0
+  :: DaeBuilder -> MX -> IO (Vector Double)
+casadi__DaeBuilder__guess__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__guess__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_guess__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
+daeBuilder_guess__0 x = casadi__DaeBuilder__guess__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__guess__1" c_casadi__DaeBuilder__guess__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__guess__1
+  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
+casadi__DaeBuilder__guess__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__guess__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_guess__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
+daeBuilder_guess__1 x = casadi__DaeBuilder__guess__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__guess__2" c_casadi__DaeBuilder__guess__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
+
+casadi__DaeBuilder__guess__2
+  :: DaeBuilder -> String -> IO Double
+casadi__DaeBuilder__guess__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__guess__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_guess__2 :: DaeBuilderClass a => a -> String -> IO Double
+daeBuilder_guess__2 x = casadi__DaeBuilder__guess__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__guess__3" c_casadi__DaeBuilder__guess__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
+
+casadi__DaeBuilder__guess__3
+  :: DaeBuilder -> String -> Bool -> IO Double
+casadi__DaeBuilder__guess__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__guess__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_guess__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
+daeBuilder_guess__3 x = casadi__DaeBuilder__guess__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__make_explicit" c_casadi__DaeBuilder__make_explicit
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__make_explicit
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__make_explicit x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__make_explicit errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_make_explicit :: DaeBuilderClass a => a -> IO ()
+daeBuilder_make_explicit x = casadi__DaeBuilder__make_explicit (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__make_semi_explicit" c_casadi__DaeBuilder__make_semi_explicit
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__make_semi_explicit
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__make_semi_explicit x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__make_semi_explicit errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_make_semi_explicit :: DaeBuilderClass a => a -> IO ()
+daeBuilder_make_semi_explicit x = casadi__DaeBuilder__make_semi_explicit (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__max__0" c_casadi__DaeBuilder__max__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__max__0
+  :: DaeBuilder -> MX -> IO (Vector Double)
+casadi__DaeBuilder__max__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__max__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_max__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
+daeBuilder_max__0 x = casadi__DaeBuilder__max__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__max__1" c_casadi__DaeBuilder__max__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__max__1
+  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
+casadi__DaeBuilder__max__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__max__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_max__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
+daeBuilder_max__1 x = casadi__DaeBuilder__max__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__max__2" c_casadi__DaeBuilder__max__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
+
+casadi__DaeBuilder__max__2
+  :: DaeBuilder -> String -> IO Double
+casadi__DaeBuilder__max__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__max__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_max__2 :: DaeBuilderClass a => a -> String -> IO Double
+daeBuilder_max__2 x = casadi__DaeBuilder__max__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__max__3" c_casadi__DaeBuilder__max__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
+
+casadi__DaeBuilder__max__3
+  :: DaeBuilder -> String -> Bool -> IO Double
+casadi__DaeBuilder__max__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__max__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_max__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
+daeBuilder_max__3 x = casadi__DaeBuilder__max__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__min__0" c_casadi__DaeBuilder__min__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__min__0
+  :: DaeBuilder -> MX -> IO (Vector Double)
+casadi__DaeBuilder__min__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__min__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_min__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
+daeBuilder_min__0 x = casadi__DaeBuilder__min__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__min__1" c_casadi__DaeBuilder__min__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__min__1
+  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
+casadi__DaeBuilder__min__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__min__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_min__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
+daeBuilder_min__1 x = casadi__DaeBuilder__min__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__min__2" c_casadi__DaeBuilder__min__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
+
+casadi__DaeBuilder__min__2
+  :: DaeBuilder -> String -> IO Double
+casadi__DaeBuilder__min__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__min__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_min__2 :: DaeBuilderClass a => a -> String -> IO Double
+daeBuilder_min__2 x = casadi__DaeBuilder__min__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__min__3" c_casadi__DaeBuilder__min__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
+
+casadi__DaeBuilder__min__3
+  :: DaeBuilder -> String -> Bool -> IO Double
+casadi__DaeBuilder__min__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__min__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_min__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
+daeBuilder_min__3 x = casadi__DaeBuilder__min__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__nominal__0" c_casadi__DaeBuilder__nominal__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__nominal__0
+  :: DaeBuilder -> MX -> IO (Vector Double)
+casadi__DaeBuilder__nominal__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__nominal__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_nominal__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
+daeBuilder_nominal__0 x = casadi__DaeBuilder__nominal__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__nominal__1" c_casadi__DaeBuilder__nominal__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
+
+casadi__DaeBuilder__nominal__1
+  :: DaeBuilder -> String -> IO Double
+casadi__DaeBuilder__nominal__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__nominal__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_nominal__1 :: DaeBuilderClass a => a -> String -> IO Double
+daeBuilder_nominal__1 x = casadi__DaeBuilder__nominal__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__operator__call" c_casadi__DaeBuilder__operator__call
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__DaeBuilder__operator__call
+  :: DaeBuilder -> String -> IO MX
+casadi__DaeBuilder__operator__call x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__operator__call errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_operator__call :: DaeBuilderClass a => a -> String -> IO MX
+daeBuilder_operator__call x = casadi__DaeBuilder__operator__call (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__parse_fmi" c_casadi__DaeBuilder__parse_fmi
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO ()
+
+casadi__DaeBuilder__parse_fmi
+  :: DaeBuilder -> String -> IO ()
+casadi__DaeBuilder__parse_fmi x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__parse_fmi errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_parse_fmi :: DaeBuilderClass a => a -> String -> IO ()
+daeBuilder_parse_fmi x = casadi__DaeBuilder__parse_fmi (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__sanity_check" c_casadi__DaeBuilder__sanity_check
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__sanity_check
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__sanity_check x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__sanity_check errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_sanity_check :: DaeBuilderClass a => a -> IO ()
+daeBuilder_sanity_check x = casadi__DaeBuilder__sanity_check (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__scale_equations" c_casadi__DaeBuilder__scale_equations
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__scale_equations
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__scale_equations x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__scale_equations errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_scale_equations :: DaeBuilderClass a => a -> IO ()
+daeBuilder_scale_equations x = casadi__DaeBuilder__scale_equations (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__scale_variables" c_casadi__DaeBuilder__scale_variables
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__scale_variables
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__scale_variables x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__scale_variables errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_scale_variables :: DaeBuilderClass a => a -> IO ()
+daeBuilder_scale_variables x = casadi__DaeBuilder__scale_variables (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_derivative_start__0" c_casadi__DaeBuilder__set_derivative_start__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
+
+casadi__DaeBuilder__set_derivative_start__0
+  :: DaeBuilder -> MX -> Vector Double -> IO ()
+casadi__DaeBuilder__set_derivative_start__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_derivative_start__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_derivative_start__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
+daeBuilder_set_derivative_start__0 x = casadi__DaeBuilder__set_derivative_start__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_derivative_start__1" c_casadi__DaeBuilder__set_derivative_start__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
+
+casadi__DaeBuilder__set_derivative_start__1
+  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
+casadi__DaeBuilder__set_derivative_start__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_derivative_start__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_derivative_start__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
+daeBuilder_set_derivative_start__1 x = casadi__DaeBuilder__set_derivative_start__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_derivative_start__2" c_casadi__DaeBuilder__set_derivative_start__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
+
+casadi__DaeBuilder__set_derivative_start__2
+  :: DaeBuilder -> String -> Double -> IO ()
+casadi__DaeBuilder__set_derivative_start__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_derivative_start__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_derivative_start__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
+daeBuilder_set_derivative_start__2 x = casadi__DaeBuilder__set_derivative_start__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_derivative_start__3" c_casadi__DaeBuilder__set_derivative_start__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
+
+casadi__DaeBuilder__set_derivative_start__3
+  :: DaeBuilder -> String -> Double -> Bool -> IO ()
+casadi__DaeBuilder__set_derivative_start__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_derivative_start__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_derivative_start__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
+daeBuilder_set_derivative_start__3 x = casadi__DaeBuilder__set_derivative_start__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_guess__0" c_casadi__DaeBuilder__set_guess__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
+
+casadi__DaeBuilder__set_guess__0
+  :: DaeBuilder -> MX -> Vector Double -> IO ()
+casadi__DaeBuilder__set_guess__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_guess__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_guess__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
+daeBuilder_set_guess__0 x = casadi__DaeBuilder__set_guess__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_guess__1" c_casadi__DaeBuilder__set_guess__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
+
+casadi__DaeBuilder__set_guess__1
+  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
+casadi__DaeBuilder__set_guess__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_guess__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_guess__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
+daeBuilder_set_guess__1 x = casadi__DaeBuilder__set_guess__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_guess__2" c_casadi__DaeBuilder__set_guess__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
+
+casadi__DaeBuilder__set_guess__2
+  :: DaeBuilder -> String -> Double -> IO ()
+casadi__DaeBuilder__set_guess__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_guess__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_guess__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
+daeBuilder_set_guess__2 x = casadi__DaeBuilder__set_guess__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_guess__3" c_casadi__DaeBuilder__set_guess__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
+
+casadi__DaeBuilder__set_guess__3
+  :: DaeBuilder -> String -> Double -> Bool -> IO ()
+casadi__DaeBuilder__set_guess__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_guess__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_guess__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
+daeBuilder_set_guess__3 x = casadi__DaeBuilder__set_guess__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_max__0" c_casadi__DaeBuilder__set_max__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
+
+casadi__DaeBuilder__set_max__0
+  :: DaeBuilder -> MX -> Vector Double -> IO ()
+casadi__DaeBuilder__set_max__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_max__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_max__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
+daeBuilder_set_max__0 x = casadi__DaeBuilder__set_max__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_max__1" c_casadi__DaeBuilder__set_max__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
+
+casadi__DaeBuilder__set_max__1
+  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
+casadi__DaeBuilder__set_max__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_max__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_max__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
+daeBuilder_set_max__1 x = casadi__DaeBuilder__set_max__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_max__2" c_casadi__DaeBuilder__set_max__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
+
+casadi__DaeBuilder__set_max__2
+  :: DaeBuilder -> String -> Double -> IO ()
+casadi__DaeBuilder__set_max__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_max__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_max__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
+daeBuilder_set_max__2 x = casadi__DaeBuilder__set_max__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_max__3" c_casadi__DaeBuilder__set_max__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
+
+casadi__DaeBuilder__set_max__3
+  :: DaeBuilder -> String -> Double -> Bool -> IO ()
+casadi__DaeBuilder__set_max__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_max__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_max__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
+daeBuilder_set_max__3 x = casadi__DaeBuilder__set_max__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_min__0" c_casadi__DaeBuilder__set_min__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
+
+casadi__DaeBuilder__set_min__0
+  :: DaeBuilder -> MX -> Vector Double -> IO ()
+casadi__DaeBuilder__set_min__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_min__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_min__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
+daeBuilder_set_min__0 x = casadi__DaeBuilder__set_min__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_min__1" c_casadi__DaeBuilder__set_min__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
+
+casadi__DaeBuilder__set_min__1
+  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
+casadi__DaeBuilder__set_min__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_min__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_min__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
+daeBuilder_set_min__1 x = casadi__DaeBuilder__set_min__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_min__2" c_casadi__DaeBuilder__set_min__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
+
+casadi__DaeBuilder__set_min__2
+  :: DaeBuilder -> String -> Double -> IO ()
+casadi__DaeBuilder__set_min__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_min__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_min__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
+daeBuilder_set_min__2 x = casadi__DaeBuilder__set_min__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_min__3" c_casadi__DaeBuilder__set_min__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
+
+casadi__DaeBuilder__set_min__3
+  :: DaeBuilder -> String -> Double -> Bool -> IO ()
+casadi__DaeBuilder__set_min__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_min__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_min__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
+daeBuilder_set_min__3 x = casadi__DaeBuilder__set_min__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_nominal__0" c_casadi__DaeBuilder__set_nominal__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
+
+casadi__DaeBuilder__set_nominal__0
+  :: DaeBuilder -> MX -> Vector Double -> IO ()
+casadi__DaeBuilder__set_nominal__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_nominal__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_nominal__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
+daeBuilder_set_nominal__0 x = casadi__DaeBuilder__set_nominal__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_nominal__1" c_casadi__DaeBuilder__set_nominal__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
+
+casadi__DaeBuilder__set_nominal__1
+  :: DaeBuilder -> String -> Double -> IO ()
+casadi__DaeBuilder__set_nominal__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_nominal__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_nominal__1 :: DaeBuilderClass a => a -> String -> Double -> IO ()
+daeBuilder_set_nominal__1 x = casadi__DaeBuilder__set_nominal__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_start__0" c_casadi__DaeBuilder__set_start__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO ()
+
+casadi__DaeBuilder__set_start__0
+  :: DaeBuilder -> MX -> Vector Double -> IO ()
+casadi__DaeBuilder__set_start__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_start__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_start__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO ()
+daeBuilder_set_start__0 x = casadi__DaeBuilder__set_start__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_start__1" c_casadi__DaeBuilder__set_start__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
+
+casadi__DaeBuilder__set_start__1
+  :: DaeBuilder -> MX -> Vector Double -> Bool -> IO ()
+casadi__DaeBuilder__set_start__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_start__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_start__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO ()
+daeBuilder_set_start__1 x = casadi__DaeBuilder__set_start__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_start__2" c_casadi__DaeBuilder__set_start__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO ()
+
+casadi__DaeBuilder__set_start__2
+  :: DaeBuilder -> String -> Double -> IO ()
+casadi__DaeBuilder__set_start__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_start__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_start__2 :: DaeBuilderClass a => a -> String -> Double -> IO ()
+daeBuilder_set_start__2 x = casadi__DaeBuilder__set_start__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_start__3" c_casadi__DaeBuilder__set_start__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO ()
+
+casadi__DaeBuilder__set_start__3
+  :: DaeBuilder -> String -> Double -> Bool -> IO ()
+casadi__DaeBuilder__set_start__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_start__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_start__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO ()
+daeBuilder_set_start__3 x = casadi__DaeBuilder__set_start__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__set_unit" c_casadi__DaeBuilder__set_unit
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr StdString -> IO ()
+
+casadi__DaeBuilder__set_unit
+  :: DaeBuilder -> String -> String -> IO ()
+casadi__DaeBuilder__set_unit x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__set_unit errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_set_unit :: DaeBuilderClass a => a -> String -> String -> IO ()
+daeBuilder_set_unit x = casadi__DaeBuilder__set_unit (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__sort_alg" c_casadi__DaeBuilder__sort_alg
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__sort_alg
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__sort_alg x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__sort_alg errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_sort_alg :: DaeBuilderClass a => a -> IO ()
+daeBuilder_sort_alg x = casadi__DaeBuilder__sort_alg (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__sort_d" c_casadi__DaeBuilder__sort_d
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__sort_d
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__sort_d x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__sort_d errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_sort_d :: DaeBuilderClass a => a -> IO ()
+daeBuilder_sort_d x = casadi__DaeBuilder__sort_d (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__sort_dae" c_casadi__DaeBuilder__sort_dae
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__sort_dae
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__sort_dae x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__sort_dae errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_sort_dae :: DaeBuilderClass a => a -> IO ()
+daeBuilder_sort_dae x = casadi__DaeBuilder__sort_dae (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__split_d" c_casadi__DaeBuilder__split_d
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__split_d
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__split_d x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__split_d errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_split_d :: DaeBuilderClass a => a -> IO ()
+daeBuilder_split_d x = casadi__DaeBuilder__split_d (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__split_dae" c_casadi__DaeBuilder__split_dae
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO ()
+
+casadi__DaeBuilder__split_dae
+  :: DaeBuilder -> IO ()
+casadi__DaeBuilder__split_dae x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__split_dae errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+daeBuilder_split_dae :: DaeBuilderClass a => a -> IO ()
+daeBuilder_split_dae x = casadi__DaeBuilder__split_dae (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__start__0" c_casadi__DaeBuilder__start__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__start__0
+  :: DaeBuilder -> MX -> IO (Vector Double)
+casadi__DaeBuilder__start__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__start__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_start__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double)
+daeBuilder_start__0 x = casadi__DaeBuilder__start__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__start__1" c_casadi__DaeBuilder__start__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble))
+
+casadi__DaeBuilder__start__1
+  :: DaeBuilder -> MX -> Bool -> IO (Vector Double)
+casadi__DaeBuilder__start__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__start__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_start__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double)
+daeBuilder_start__1 x = casadi__DaeBuilder__start__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__start__2" c_casadi__DaeBuilder__start__2
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble
+
+casadi__DaeBuilder__start__2
+  :: DaeBuilder -> String -> IO Double
+casadi__DaeBuilder__start__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__start__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_start__2 :: DaeBuilderClass a => a -> String -> IO Double
+daeBuilder_start__2 x = casadi__DaeBuilder__start__2 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__start__3" c_casadi__DaeBuilder__start__3
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble
+
+casadi__DaeBuilder__start__3
+  :: DaeBuilder -> String -> Bool -> IO Double
+casadi__DaeBuilder__start__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__start__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_start__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double
+daeBuilder_start__3 x = casadi__DaeBuilder__start__3 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__unit__0" c_casadi__DaeBuilder__unit__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr StdString)
+
+casadi__DaeBuilder__unit__0
+  :: DaeBuilder -> MX -> IO String
+casadi__DaeBuilder__unit__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__unit__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_unit__0 :: DaeBuilderClass a => a -> MX -> IO String
+daeBuilder_unit__0 x = casadi__DaeBuilder__unit__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__unit__1" c_casadi__DaeBuilder__unit__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr StdString)
+
+casadi__DaeBuilder__unit__1
+  :: DaeBuilder -> String -> IO String
+casadi__DaeBuilder__unit__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__unit__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_unit__1 :: DaeBuilderClass a => a -> String -> IO String
+daeBuilder_unit__1 x = casadi__DaeBuilder__unit__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__variable__0" c_casadi__DaeBuilder__variable__0
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr Variable')
+
+casadi__DaeBuilder__variable__0
+  :: DaeBuilder -> String -> IO Variable
+casadi__DaeBuilder__variable__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__variable__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_variable__0 :: DaeBuilderClass a => a -> String -> IO Variable
+daeBuilder_variable__0 x = casadi__DaeBuilder__variable__0 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__variable__1" c_casadi__DaeBuilder__variable__1
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr Variable')
+
+casadi__DaeBuilder__variable__1
+  :: DaeBuilder -> String -> IO Variable
+casadi__DaeBuilder__variable__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__variable__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_variable__1 :: DaeBuilderClass a => a -> String -> IO Variable
+daeBuilder_variable__1 x = casadi__DaeBuilder__variable__1 (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__getRepresentation" c_casadi__DaeBuilder__getRepresentation
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr StdString)
+
+casadi__DaeBuilder__getRepresentation
+  :: DaeBuilder -> IO String
+casadi__DaeBuilder__getRepresentation x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+daeBuilder_getRepresentation :: DaeBuilderClass a => a -> IO String
+daeBuilder_getRepresentation x = casadi__DaeBuilder__getRepresentation (castDaeBuilder x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DaeBuilder__getDescription" c_casadi__DaeBuilder__getDescription
+  :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr StdString)
+
+casadi__DaeBuilder__getDescription
+  :: DaeBuilder -> IO String
+casadi__DaeBuilder__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__DaeBuilder__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/DerivativeGenerator.hs b/Casadi/Core/Classes/DerivativeGenerator.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/DerivativeGenerator.hs
+++ /dev/null
@@ -1,51 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.DerivativeGenerator
-       (
-         DerivativeGenerator,
-         DerivativeGeneratorClass(..),
-         derivativeGenerator,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__DerivativeGenerator__CONSTRUCTOR" c_casadi__DerivativeGenerator__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr DerivativeGenerator')
-casadi__DerivativeGenerator__CONSTRUCTOR
-  :: IO DerivativeGenerator
-casadi__DerivativeGenerator__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DerivativeGenerator__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-derivativeGenerator :: IO DerivativeGenerator
-derivativeGenerator = casadi__DerivativeGenerator__CONSTRUCTOR
-
diff --git a/Casadi/Core/Classes/DerivativeGenerator2.hs b/Casadi/Core/Classes/DerivativeGenerator2.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/DerivativeGenerator2.hs
+++ /dev/null
@@ -1,119 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.DerivativeGenerator2
-       (
-         DerivativeGenerator2,
-         DerivativeGenerator2Class(..),
-         derivativeGenerator2,
-         derivativeGenerator2_create,
-         derivativeGenerator2_operator_call,
-         derivativeGenerator2_original,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__DerivativeGenerator2__CONSTRUCTOR" c_casadi__DerivativeGenerator2__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr DerivativeGenerator2')
-casadi__DerivativeGenerator2__CONSTRUCTOR
-  :: IO DerivativeGenerator2
-casadi__DerivativeGenerator2__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DerivativeGenerator2__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-derivativeGenerator2 :: IO DerivativeGenerator2
-derivativeGenerator2 = casadi__DerivativeGenerator2__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DerivativeGenerator2__create" c_casadi__DerivativeGenerator2__create
-  :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator2' -> IO (Ptr DerivativeGenerator')
-casadi__DerivativeGenerator2__create
-  :: DerivativeGenerator2 -> IO DerivativeGenerator
-casadi__DerivativeGenerator2__create x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DerivativeGenerator2__create errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-derivativeGenerator2_create :: DerivativeGenerator2Class a => a -> IO DerivativeGenerator
-derivativeGenerator2_create x = casadi__DerivativeGenerator2__create (castDerivativeGenerator2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DerivativeGenerator2__operator_call" c_casadi__DerivativeGenerator2__operator_call
-  :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator2' -> Ptr Function' -> CInt -> IO (Ptr Function')
-casadi__DerivativeGenerator2__operator_call
-  :: DerivativeGenerator2 -> Function -> Int -> IO Function
-casadi__DerivativeGenerator2__operator_call x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DerivativeGenerator2__operator_call errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-derivativeGenerator2_operator_call :: DerivativeGenerator2Class a => a -> Function -> Int -> IO Function
-derivativeGenerator2_operator_call x = casadi__DerivativeGenerator2__operator_call (castDerivativeGenerator2 x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DerivativeGenerator2__original" c_casadi__DerivativeGenerator2__original
-  :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator2' -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
-casadi__DerivativeGenerator2__original
-  :: DerivativeGenerator2 -> Function -> Int -> Bool -> IO Function
-casadi__DerivativeGenerator2__original x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DerivativeGenerator2__original errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-derivativeGenerator2_original :: DerivativeGenerator2Class a => a -> Function -> Int -> Bool -> IO Function
-derivativeGenerator2_original x = casadi__DerivativeGenerator2__original (castDerivativeGenerator2 x)
-
diff --git a/Casadi/Core/Classes/DleSolver.hs b/Casadi/Core/Classes/DleSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/DleSolver.hs
+++ /dev/null
@@ -1,224 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.DleSolver
-       (
-         DleSolver,
-         DleSolverClass(..),
-         dleSolver__0,
-         dleSolver__1,
-         dleSolver__2,
-         dleSolver_clone,
-         dleSolver_doc,
-         dleSolver_getSparsity,
-         dleSolver_hasPlugin,
-         dleSolver_loadPlugin,
-         dleSolver_printStats,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__CONSTRUCTOR__0" c_casadi__DleSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr DleSolver')
-casadi__DleSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO DleSolver
-casadi__DleSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver__0 :: String -> String -> M.Map String Sparsity -> IO DleSolver
-dleSolver__0 = casadi__DleSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__CONSTRUCTOR__1" c_casadi__DleSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DleSolver')
-casadi__DleSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO DleSolver
-casadi__DleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO DleSolver
-dleSolver__1 = casadi__DleSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__CONSTRUCTOR__2" c_casadi__DleSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr DleSolver')
-casadi__DleSolver__CONSTRUCTOR__2
-  :: IO DleSolver
-casadi__DleSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver__2 :: IO DleSolver
-dleSolver__2 = casadi__DleSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__clone" c_casadi__DleSolver__clone
-  :: Ptr (Ptr StdString) -> Ptr DleSolver' -> IO (Ptr DleSolver')
-casadi__DleSolver__clone
-  :: DleSolver -> IO DleSolver
-casadi__DleSolver__clone x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__clone errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver_clone :: DleSolverClass a => a -> IO DleSolver
-dleSolver_clone x = casadi__DleSolver__clone (castDleSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__doc" c_casadi__DleSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__DleSolver__doc
-  :: String -> IO String
-casadi__DleSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver_doc :: String -> IO String
-dleSolver_doc = casadi__DleSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__getSparsity" c_casadi__DleSolver__getSparsity
-  :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr Sparsity')
-casadi__DleSolver__getSparsity
-  :: M.Map String Sparsity -> IO Sparsity
-casadi__DleSolver__getSparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__getSparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver_getSparsity :: M.Map String Sparsity -> IO Sparsity
-dleSolver_getSparsity = casadi__DleSolver__getSparsity
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__hasPlugin" c_casadi__DleSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__DleSolver__hasPlugin
-  :: String -> IO Bool
-casadi__DleSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver_hasPlugin :: String -> IO Bool
-dleSolver_hasPlugin = casadi__DleSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__loadPlugin" c_casadi__DleSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__DleSolver__loadPlugin
-  :: String -> IO ()
-casadi__DleSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver_loadPlugin :: String -> IO ()
-dleSolver_loadPlugin = casadi__DleSolver__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DleSolver__printStats" c_casadi__DleSolver__printStats
-  :: Ptr (Ptr StdString) -> Ptr DleSolver' -> IO ()
-casadi__DleSolver__printStats
-  :: DleSolver -> IO ()
-casadi__DleSolver__printStats x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DleSolver__printStats errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dleSolver_printStats :: DleSolverClass a => a -> IO ()
-dleSolver_printStats x = casadi__DleSolver__printStats (castDleSolver x)
-
diff --git a/Casadi/Core/Classes/DpleSolver.hs b/Casadi/Core/Classes/DpleSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/DpleSolver.hs
+++ /dev/null
@@ -1,256 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.DpleSolver
-       (
-         DpleSolver,
-         DpleSolverClass(..),
-         dpleSolver__0,
-         dpleSolver__1,
-         dpleSolver__2,
-         dpleSolver_clone,
-         dpleSolver_doc,
-         dpleSolver_hasPlugin,
-         dpleSolver_loadPlugin,
-         dpleSolver_periodic_schur__0,
-         dpleSolver_periodic_schur__1,
-         dpleSolver_printStats,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__CONSTRUCTOR__0" c_casadi__DpleSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr DpleSolver')
-casadi__DpleSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String (Vector Sparsity) -> IO DpleSolver
-casadi__DpleSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver__0 :: String -> String -> M.Map String (Vector Sparsity) -> IO DpleSolver
-dpleSolver__0 = casadi__DpleSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__CONSTRUCTOR__1" c_casadi__DpleSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DpleSolver')
-casadi__DpleSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO DpleSolver
-casadi__DpleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver__1 :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO DpleSolver
-dpleSolver__1 = casadi__DpleSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__CONSTRUCTOR__2" c_casadi__DpleSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr DpleSolver')
-casadi__DpleSolver__CONSTRUCTOR__2
-  :: IO DpleSolver
-casadi__DpleSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver__2 :: IO DpleSolver
-dpleSolver__2 = casadi__DpleSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__clone" c_casadi__DpleSolver__clone
-  :: Ptr (Ptr StdString) -> Ptr DpleSolver' -> IO (Ptr DpleSolver')
-casadi__DpleSolver__clone
-  :: DpleSolver -> IO DpleSolver
-casadi__DpleSolver__clone x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__clone errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver_clone :: DpleSolverClass a => a -> IO DpleSolver
-dpleSolver_clone x = casadi__DpleSolver__clone (castDpleSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__doc" c_casadi__DpleSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__DpleSolver__doc
-  :: String -> IO String
-casadi__DpleSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver_doc :: String -> IO String
-dpleSolver_doc = casadi__DpleSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__hasPlugin" c_casadi__DpleSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__DpleSolver__hasPlugin
-  :: String -> IO Bool
-casadi__DpleSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver_hasPlugin :: String -> IO Bool
-dpleSolver_hasPlugin = casadi__DpleSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__loadPlugin" c_casadi__DpleSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__DpleSolver__loadPlugin
-  :: String -> IO ()
-casadi__DpleSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver_loadPlugin :: String -> IO ()
-dpleSolver_loadPlugin = casadi__DpleSolver__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__periodic_schur__0" c_casadi__DpleSolver__periodic_schur__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> IO ()
-casadi__DpleSolver__periodic_schur__0
-  :: String -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector Double -> Vector Double -> IO ()
-casadi__DpleSolver__periodic_schur__0 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__periodic_schur__0 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver_periodic_schur__0 :: String -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector Double -> Vector Double -> IO ()
-dpleSolver_periodic_schur__0 = casadi__DpleSolver__periodic_schur__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__periodic_schur__1" c_casadi__DpleSolver__periodic_schur__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> CDouble -> IO ()
-casadi__DpleSolver__periodic_schur__1
-  :: String -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector Double -> Vector Double -> Double -> IO ()
-casadi__DpleSolver__periodic_schur__1 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__periodic_schur__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver_periodic_schur__1 :: String -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector Double -> Vector Double -> Double -> IO ()
-dpleSolver_periodic_schur__1 = casadi__DpleSolver__periodic_schur__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__DpleSolver__printStats" c_casadi__DpleSolver__printStats
-  :: Ptr (Ptr StdString) -> Ptr DpleSolver' -> IO ()
-casadi__DpleSolver__printStats
-  :: DpleSolver -> IO ()
-casadi__DpleSolver__printStats x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__DpleSolver__printStats errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-dpleSolver_printStats :: DpleSolverClass a => a -> IO ()
-dpleSolver_printStats x = casadi__DpleSolver__printStats (castDpleSolver x)
-
diff --git a/Casadi/Core/Classes/ExternalFunction.hs b/Casadi/Core/Classes/ExternalFunction.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/ExternalFunction.hs
+++ /dev/null
@@ -1,184 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.ExternalFunction
-       (
-         ExternalFunction,
-         ExternalFunctionClass(..),
-         externalFunction__0,
-         externalFunction__1,
-         externalFunction__2,
-         externalFunction__3,
-         externalFunction__4,
-         externalFunction__5,
-         externalFunction__6,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__0" c_casadi__ExternalFunction__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Compiler' -> IO (Ptr ExternalFunction')
-casadi__ExternalFunction__CONSTRUCTOR__0
-  :: String -> Compiler -> IO ExternalFunction
-casadi__ExternalFunction__CONSTRUCTOR__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ExternalFunction__CONSTRUCTOR__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-externalFunction__0 :: String -> Compiler -> IO ExternalFunction
-externalFunction__0 = casadi__ExternalFunction__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__1" c_casadi__ExternalFunction__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Compiler' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ExternalFunction')
-casadi__ExternalFunction__CONSTRUCTOR__1
-  :: String -> Compiler -> M.Map String GenericType -> IO ExternalFunction
-casadi__ExternalFunction__CONSTRUCTOR__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ExternalFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-externalFunction__1 :: String -> Compiler -> M.Map String GenericType -> IO ExternalFunction
-externalFunction__1 = casadi__ExternalFunction__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__2" c_casadi__ExternalFunction__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr ExternalFunction')
-casadi__ExternalFunction__CONSTRUCTOR__2
-  :: String -> String -> IO ExternalFunction
-casadi__ExternalFunction__CONSTRUCTOR__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ExternalFunction__CONSTRUCTOR__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-externalFunction__2 :: String -> String -> IO ExternalFunction
-externalFunction__2 = casadi__ExternalFunction__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__3" c_casadi__ExternalFunction__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ExternalFunction')
-casadi__ExternalFunction__CONSTRUCTOR__3
-  :: String -> String -> M.Map String GenericType -> IO ExternalFunction
-casadi__ExternalFunction__CONSTRUCTOR__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ExternalFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-externalFunction__3 :: String -> String -> M.Map String GenericType -> IO ExternalFunction
-externalFunction__3 = casadi__ExternalFunction__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__4" c_casadi__ExternalFunction__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr ExternalFunction')
-casadi__ExternalFunction__CONSTRUCTOR__4
-  :: String -> IO ExternalFunction
-casadi__ExternalFunction__CONSTRUCTOR__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ExternalFunction__CONSTRUCTOR__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-externalFunction__4 :: String -> IO ExternalFunction
-externalFunction__4 = casadi__ExternalFunction__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__5" c_casadi__ExternalFunction__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ExternalFunction')
-casadi__ExternalFunction__CONSTRUCTOR__5
-  :: String -> M.Map String GenericType -> IO ExternalFunction
-casadi__ExternalFunction__CONSTRUCTOR__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ExternalFunction__CONSTRUCTOR__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-externalFunction__5 :: String -> M.Map String GenericType -> IO ExternalFunction
-externalFunction__5 = casadi__ExternalFunction__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__6" c_casadi__ExternalFunction__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> IO (Ptr ExternalFunction')
-casadi__ExternalFunction__CONSTRUCTOR__6
-  :: IO ExternalFunction
-casadi__ExternalFunction__CONSTRUCTOR__6  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ExternalFunction__CONSTRUCTOR__6 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-externalFunction__6 :: IO ExternalFunction
-externalFunction__6 = casadi__ExternalFunction__CONSTRUCTOR__6
-
diff --git a/Casadi/Core/Classes/Function.hs b/Casadi/Core/Classes/Function.hs
--- a/Casadi/Core/Classes/Function.hs
+++ b/Casadi/Core/Classes/Function.hs
@@ -9,4212 +9,8346 @@
        (
          Function,
          FunctionClass(..),
-         function,
-         function_addMonitor,
-         function_callDerivative__0,
-         function_callDerivative__1,
-         function_callDerivative__2,
-         function_callDerivative__3,
-         function_callDerivative__4,
-         function_callDerivative__5,
-         function_callDerivative__6,
-         function_callDerivative__7,
-         function_callDerivative__8,
-         function_callForward__0,
-         function_callForward__1,
-         function_callForward__2,
-         function_callForward__3,
-         function_callForward__4,
-         function_callForward__5,
-         function_callForward__6,
-         function_callForward__7,
-         function_callForward__8,
-         function_callReverse__0,
-         function_callReverse__1,
-         function_callReverse__2,
-         function_callReverse__3,
-         function_callReverse__4,
-         function_callReverse__5,
-         function_callReverse__6,
-         function_callReverse__7,
-         function_callReverse__8,
-         function_call__0,
-         function_call__1,
-         function_call__2,
-         function_call__3,
-         function_call__4,
-         function_call__5,
-         function_call__6,
-         function_call__7,
-         function_call__8,
-         function_checkInputs,
-         function_defaultInput,
-         function_derForward,
-         function_derReverse,
-         function_derivative,
-         function_evaluate,
-         function_fullJacobian,
-         function_generate__0,
-         function_generate__1,
-         function_generate__2,
-         function_generate__3,
-         function_getSanitizedName,
-         function_getStat,
-         function_getStats,
-         function_gradient__0,
-         function_gradient__1,
-         function_gradient__2,
-         function_gradient__3,
-         function_gradient__4,
-         function_gradient__5,
-         function_gradient__6,
-         function_hessian__0,
-         function_hessian__1,
-         function_hessian__2,
-         function_hessian__3,
-         function_hessian__4,
-         function_hessian__5,
-         function_hessian__6,
-         function_inputDescription,
-         function_inputIndex,
-         function_inputName,
-         function_inputScheme,
-         function_inputSparsity__0,
-         function_inputSparsity__1,
-         function_inputSparsity__2,
-         function_jacSparsity__0,
-         function_jacSparsity__1,
-         function_jacSparsity__10,
-         function_jacSparsity__11,
-         function_jacSparsity__12,
-         function_jacSparsity__13,
-         function_jacSparsity__14,
-         function_jacSparsity__2,
-         function_jacSparsity__3,
-         function_jacSparsity__4,
-         function_jacSparsity__5,
-         function_jacSparsity__6,
-         function_jacSparsity__7,
-         function_jacSparsity__8,
-         function_jacSparsity__9,
-         function_jacobian__0,
-         function_jacobian__1,
-         function_jacobian__10,
-         function_jacobian__11,
-         function_jacobian__12,
-         function_jacobian__13,
-         function_jacobian__14,
-         function_jacobian__2,
-         function_jacobian__3,
-         function_jacobian__4,
-         function_jacobian__5,
-         function_jacobian__6,
-         function_jacobian__7,
-         function_jacobian__8,
-         function_jacobian__9,
-         function_map__0,
-         function_map__1,
-         function_map__2,
-         function_map__3,
-         function_map__4,
-         function_map__5,
-         function_mapaccum__0,
-         function_mapaccum__1,
-         function_mapsum__0,
-         function_mapsum__1,
-         function_nIn,
-         function_nOut,
-         function_nnzIn,
-         function_nnzOut,
-         function_numelIn,
-         function_numelOut,
-         function_operator_call__0,
-         function_operator_call__1,
-         function_operator_call__10,
-         function_operator_call__11,
-         function_operator_call__12,
-         function_operator_call__13,
-         function_operator_call__14,
-         function_operator_call__15,
-         function_operator_call__16,
-         function_operator_call__17,
-         function_operator_call__2,
-         function_operator_call__3,
-         function_operator_call__4,
-         function_operator_call__5,
-         function_operator_call__6,
-         function_operator_call__7,
-         function_operator_call__8,
-         function_operator_call__9,
-         function_outputDescription,
-         function_outputIndex,
-         function_outputName,
-         function_outputScheme,
-         function_outputSparsity__0,
-         function_outputSparsity__1,
-         function_outputSparsity__2,
-         function_printDimensions,
-         function_removeMonitor,
-         function_sanitizeName,
-         function_setDerForward,
-         function_setDerReverse,
-         function_setFullJacobian,
-         function_setJacSparsity__0,
-         function_setJacSparsity__1,
-         function_setJacSparsity__2,
-         function_setJacSparsity__3,
-         function_setJacSparsity__4,
-         function_setJacSparsity__5,
-         function_setJacSparsity__6,
-         function_setJacSparsity__7,
-         function_setJacobian__0,
-         function_setJacobian__1,
-         function_setJacobian__2,
-         function_setJacobian__3,
-         function_spCanEvaluate,
-         function_spEvaluate,
-         function_spInit,
-         function_symbolicInputSX,
-         function_symbolicInput__0,
-         function_symbolicInput__1,
-         function_symbolicOutput,
-         function_sz_arg,
-         function_sz_iw,
-         function_sz_res,
-         function_sz_w,
-         function_tangent__0,
-         function_tangent__1,
-         function_tangent__2,
-         function_tangent__3,
-         function_tangent__4,
-         function_tangent__5,
-         function_tangent__6,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__CONSTRUCTOR" c_casadi__Function__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr Function')
-casadi__Function__CONSTRUCTOR
-  :: IO Function
-casadi__Function__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function :: IO Function
-function = casadi__Function__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__addMonitor" c_casadi__Function__addMonitor
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
-casadi__Function__addMonitor
-  :: Function -> String -> IO ()
-casadi__Function__addMonitor x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__addMonitor errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_addMonitor :: FunctionClass a => a -> String -> IO ()
-function_addMonitor x = casadi__Function__addMonitor (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__0" c_casadi__Function__call__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
-casadi__Function__call__0
-  :: Function -> Vector MX -> Vector MX -> IO ()
-casadi__Function__call__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> IO ()
-function_call__0 x = casadi__Function__call__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__1" c_casadi__Function__call__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO ()
-casadi__Function__call__1
-  :: Function -> Vector MX -> Vector MX -> Bool -> IO ()
-casadi__Function__call__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> IO ()
-function_call__1 x = casadi__Function__call__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__2" c_casadi__Function__call__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO ()
-casadi__Function__call__2
-  :: Function -> Vector MX -> Vector MX -> Bool -> Bool -> IO ()
-casadi__Function__call__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> Bool -> IO ()
-function_call__2 x = casadi__Function__call__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__3" c_casadi__Function__call__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
-casadi__Function__call__3
-  :: Function -> Vector SX -> Vector SX -> IO ()
-casadi__Function__call__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> IO ()
-function_call__3 x = casadi__Function__call__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__4" c_casadi__Function__call__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
-casadi__Function__call__4
-  :: Function -> Vector SX -> Vector SX -> Bool -> IO ()
-casadi__Function__call__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> IO ()
-function_call__4 x = casadi__Function__call__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__5" c_casadi__Function__call__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO ()
-casadi__Function__call__5
-  :: Function -> Vector SX -> Vector SX -> Bool -> Bool -> IO ()
-casadi__Function__call__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> Bool -> IO ()
-function_call__5 x = casadi__Function__call__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__6" c_casadi__Function__call__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO ()
-casadi__Function__call__6
-  :: Function -> Vector DMatrix -> Vector DMatrix -> IO ()
-casadi__Function__call__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> IO ()
-function_call__6 x = casadi__Function__call__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__7" c_casadi__Function__call__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO ()
-casadi__Function__call__7
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> IO ()
-casadi__Function__call__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> IO ()
-function_call__7 x = casadi__Function__call__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__call__8" c_casadi__Function__call__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO ()
-casadi__Function__call__8
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO ()
-casadi__Function__call__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__call__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_call__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO ()
-function_call__8 x = casadi__Function__call__8 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__0" c_casadi__Function__callDerivative__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO ()
-casadi__Function__callDerivative__0
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
-casadi__Function__callDerivative__0 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
-function_callDerivative__0 x = casadi__Function__callDerivative__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__1" c_casadi__Function__callDerivative__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO ()
-casadi__Function__callDerivative__1
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
-casadi__Function__callDerivative__1 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
-function_callDerivative__1 x = casadi__Function__callDerivative__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__2" c_casadi__Function__callDerivative__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO ()
-casadi__Function__callDerivative__2
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
-casadi__Function__callDerivative__2 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
-function_callDerivative__2 x = casadi__Function__callDerivative__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__3" c_casadi__Function__callDerivative__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO ()
-casadi__Function__callDerivative__3
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
-casadi__Function__callDerivative__3 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__3 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
-function_callDerivative__3 x = casadi__Function__callDerivative__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__4" c_casadi__Function__callDerivative__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO ()
-casadi__Function__callDerivative__4
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
-casadi__Function__callDerivative__4 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__4 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
-function_callDerivative__4 x = casadi__Function__callDerivative__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__5" c_casadi__Function__callDerivative__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO ()
-casadi__Function__callDerivative__5
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
-casadi__Function__callDerivative__5 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
-function_callDerivative__5 x = casadi__Function__callDerivative__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__6" c_casadi__Function__callDerivative__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO ()
-casadi__Function__callDerivative__6
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
-casadi__Function__callDerivative__6 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
-function_callDerivative__6 x = casadi__Function__callDerivative__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__7" c_casadi__Function__callDerivative__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO ()
-casadi__Function__callDerivative__7
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
-casadi__Function__callDerivative__7 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
-function_callDerivative__7 x = casadi__Function__callDerivative__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callDerivative__8" c_casadi__Function__callDerivative__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO ()
-casadi__Function__callDerivative__8
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
-casadi__Function__callDerivative__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callDerivative__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callDerivative__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
-function_callDerivative__8 x = casadi__Function__callDerivative__8 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__0" c_casadi__Function__callForward__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO ()
-casadi__Function__callForward__0
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
-casadi__Function__callForward__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
-function_callForward__0 x = casadi__Function__callForward__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__1" c_casadi__Function__callForward__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO ()
-casadi__Function__callForward__1
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
-casadi__Function__callForward__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
-function_callForward__1 x = casadi__Function__callForward__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__2" c_casadi__Function__callForward__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO ()
-casadi__Function__callForward__2
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
-casadi__Function__callForward__2 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
-function_callForward__2 x = casadi__Function__callForward__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__3" c_casadi__Function__callForward__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO ()
-casadi__Function__callForward__3
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
-casadi__Function__callForward__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
-function_callForward__3 x = casadi__Function__callForward__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__4" c_casadi__Function__callForward__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO ()
-casadi__Function__callForward__4
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
-casadi__Function__callForward__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
-function_callForward__4 x = casadi__Function__callForward__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__5" c_casadi__Function__callForward__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO ()
-casadi__Function__callForward__5
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
-casadi__Function__callForward__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
-function_callForward__5 x = casadi__Function__callForward__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__6" c_casadi__Function__callForward__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO ()
-casadi__Function__callForward__6
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
-casadi__Function__callForward__6 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__6 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
-function_callForward__6 x = casadi__Function__callForward__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__7" c_casadi__Function__callForward__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO ()
-casadi__Function__callForward__7
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
-casadi__Function__callForward__7 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__7 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
-function_callForward__7 x = casadi__Function__callForward__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callForward__8" c_casadi__Function__callForward__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO ()
-casadi__Function__callForward__8
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
-casadi__Function__callForward__8 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callForward__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callForward__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
-function_callForward__8 x = casadi__Function__callForward__8 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__0" c_casadi__Function__callReverse__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO ()
-casadi__Function__callReverse__0
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
-casadi__Function__callReverse__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
-function_callReverse__0 x = casadi__Function__callReverse__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__1" c_casadi__Function__callReverse__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO ()
-casadi__Function__callReverse__1
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
-casadi__Function__callReverse__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
-function_callReverse__1 x = casadi__Function__callReverse__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__2" c_casadi__Function__callReverse__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO ()
-casadi__Function__callReverse__2
-  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
-casadi__Function__callReverse__2 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
-function_callReverse__2 x = casadi__Function__callReverse__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__3" c_casadi__Function__callReverse__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO ()
-casadi__Function__callReverse__3
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
-casadi__Function__callReverse__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
-function_callReverse__3 x = casadi__Function__callReverse__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__4" c_casadi__Function__callReverse__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO ()
-casadi__Function__callReverse__4
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
-casadi__Function__callReverse__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
-function_callReverse__4 x = casadi__Function__callReverse__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__5" c_casadi__Function__callReverse__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO ()
-casadi__Function__callReverse__5
-  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
-casadi__Function__callReverse__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
-function_callReverse__5 x = casadi__Function__callReverse__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__6" c_casadi__Function__callReverse__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO ()
-casadi__Function__callReverse__6
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
-casadi__Function__callReverse__6 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__6 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
-function_callReverse__6 x = casadi__Function__callReverse__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__7" c_casadi__Function__callReverse__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO ()
-casadi__Function__callReverse__7
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
-casadi__Function__callReverse__7 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__7 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
-function_callReverse__7 x = casadi__Function__callReverse__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__callReverse__8" c_casadi__Function__callReverse__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO ()
-casadi__Function__callReverse__8
-  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
-casadi__Function__callReverse__8 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__callReverse__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_callReverse__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
-function_callReverse__8 x = casadi__Function__callReverse__8 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__checkInputs" c_casadi__Function__checkInputs
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
-casadi__Function__checkInputs
-  :: Function -> IO ()
-casadi__Function__checkInputs x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__checkInputs errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_checkInputs :: FunctionClass a => a -> IO ()
-function_checkInputs x = casadi__Function__checkInputs (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__defaultInput" c_casadi__Function__defaultInput
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CDouble
-casadi__Function__defaultInput
-  :: Function -> Int -> IO Double
-casadi__Function__defaultInput x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__defaultInput errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_defaultInput :: FunctionClass a => a -> Int -> IO Double
-function_defaultInput x = casadi__Function__defaultInput (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__derForward" c_casadi__Function__derForward
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
-casadi__Function__derForward
-  :: Function -> Int -> IO Function
-casadi__Function__derForward x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__derForward errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_derForward :: FunctionClass a => a -> Int -> IO Function
-function_derForward x = casadi__Function__derForward (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__derReverse" c_casadi__Function__derReverse
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
-casadi__Function__derReverse
-  :: Function -> Int -> IO Function
-casadi__Function__derReverse x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__derReverse errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_derReverse :: FunctionClass a => a -> Int -> IO Function
-function_derReverse x = casadi__Function__derReverse (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__derivative" c_casadi__Function__derivative
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__derivative
-  :: Function -> Int -> Int -> IO Function
-casadi__Function__derivative x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__derivative errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_derivative :: FunctionClass a => a -> Int -> Int -> IO Function
-function_derivative x = casadi__Function__derivative (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__evaluate" c_casadi__Function__evaluate
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
-casadi__Function__evaluate
-  :: Function -> IO ()
-casadi__Function__evaluate x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__evaluate errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_evaluate :: FunctionClass a => a -> IO ()
-function_evaluate x = casadi__Function__evaluate (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__fullJacobian" c_casadi__Function__fullJacobian
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
-casadi__Function__fullJacobian
-  :: Function -> IO Function
-casadi__Function__fullJacobian x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__fullJacobian errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_fullJacobian :: FunctionClass a => a -> IO Function
-function_fullJacobian x = casadi__Function__fullJacobian (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__generate__0" c_casadi__Function__generate__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
-casadi__Function__generate__0
-  :: Function -> IO ()
-casadi__Function__generate__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__generate__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_generate__0 :: FunctionClass a => a -> IO ()
-function_generate__0 x = casadi__Function__generate__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__generate__1" c_casadi__Function__generate__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
-casadi__Function__generate__1
-  :: Function -> M.Map String GenericType -> IO ()
-casadi__Function__generate__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__generate__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_generate__1 :: FunctionClass a => a -> M.Map String GenericType -> IO ()
-function_generate__1 x = casadi__Function__generate__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__generate__2" c_casadi__Function__generate__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
-casadi__Function__generate__2
-  :: Function -> String -> IO ()
-casadi__Function__generate__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__generate__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_generate__2 :: FunctionClass a => a -> String -> IO ()
-function_generate__2 x = casadi__Function__generate__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__generate__3" c_casadi__Function__generate__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
-casadi__Function__generate__3
-  :: Function -> String -> M.Map String GenericType -> IO ()
-casadi__Function__generate__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__generate__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_generate__3 :: FunctionClass a => a -> String -> M.Map String GenericType -> IO ()
-function_generate__3 x = casadi__Function__generate__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__getSanitizedName" c_casadi__Function__getSanitizedName
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString)
-casadi__Function__getSanitizedName
-  :: Function -> IO String
-casadi__Function__getSanitizedName x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__getSanitizedName errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_getSanitizedName :: FunctionClass a => a -> IO String
-function_getSanitizedName x = casadi__Function__getSanitizedName (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__getStat" c_casadi__Function__getStat
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr GenericType')
-casadi__Function__getStat
-  :: Function -> String -> IO GenericType
-casadi__Function__getStat x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__getStat errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_getStat :: FunctionClass a => a -> String -> IO GenericType
-function_getStat x = casadi__Function__getStat (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__getStats" c_casadi__Function__getStats
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdMap StdString (Ptr GenericType')))
-casadi__Function__getStats
-  :: Function -> IO (M.Map String GenericType)
-casadi__Function__getStats x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__getStats errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_getStats :: FunctionClass a => a -> IO (M.Map String GenericType)
-function_getStats x = casadi__Function__getStats (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__gradient__0" c_casadi__Function__gradient__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__gradient__0
-  :: Function -> String -> String -> IO Function
-casadi__Function__gradient__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__gradient__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_gradient__0 :: FunctionClass a => a -> String -> String -> IO Function
-function_gradient__0 x = casadi__Function__gradient__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__gradient__1" c_casadi__Function__gradient__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__gradient__1
-  :: Function -> Int -> String -> IO Function
-casadi__Function__gradient__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__gradient__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_gradient__1 :: FunctionClass a => a -> Int -> String -> IO Function
-function_gradient__1 x = casadi__Function__gradient__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__gradient__2" c_casadi__Function__gradient__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__gradient__2
-  :: Function -> String -> IO Function
-casadi__Function__gradient__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__gradient__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_gradient__2 :: FunctionClass a => a -> String -> IO Function
-function_gradient__2 x = casadi__Function__gradient__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__gradient__3" c_casadi__Function__gradient__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__gradient__3
-  :: Function -> String -> Int -> IO Function
-casadi__Function__gradient__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__gradient__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_gradient__3 :: FunctionClass a => a -> String -> Int -> IO Function
-function_gradient__3 x = casadi__Function__gradient__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__gradient__4" c_casadi__Function__gradient__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
-casadi__Function__gradient__4
-  :: Function -> IO Function
-casadi__Function__gradient__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__gradient__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_gradient__4 :: FunctionClass a => a -> IO Function
-function_gradient__4 x = casadi__Function__gradient__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__gradient__5" c_casadi__Function__gradient__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
-casadi__Function__gradient__5
-  :: Function -> Int -> IO Function
-casadi__Function__gradient__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__gradient__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_gradient__5 :: FunctionClass a => a -> Int -> IO Function
-function_gradient__5 x = casadi__Function__gradient__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__gradient__6" c_casadi__Function__gradient__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__gradient__6
-  :: Function -> Int -> Int -> IO Function
-casadi__Function__gradient__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__gradient__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_gradient__6 :: FunctionClass a => a -> Int -> Int -> IO Function
-function_gradient__6 x = casadi__Function__gradient__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__hessian__0" c_casadi__Function__hessian__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__hessian__0
-  :: Function -> String -> String -> IO Function
-casadi__Function__hessian__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__hessian__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_hessian__0 :: FunctionClass a => a -> String -> String -> IO Function
-function_hessian__0 x = casadi__Function__hessian__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__hessian__1" c_casadi__Function__hessian__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__hessian__1
-  :: Function -> Int -> String -> IO Function
-casadi__Function__hessian__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__hessian__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_hessian__1 :: FunctionClass a => a -> Int -> String -> IO Function
-function_hessian__1 x = casadi__Function__hessian__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__hessian__2" c_casadi__Function__hessian__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__hessian__2
-  :: Function -> String -> IO Function
-casadi__Function__hessian__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__hessian__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_hessian__2 :: FunctionClass a => a -> String -> IO Function
-function_hessian__2 x = casadi__Function__hessian__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__hessian__3" c_casadi__Function__hessian__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__hessian__3
-  :: Function -> String -> Int -> IO Function
-casadi__Function__hessian__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__hessian__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_hessian__3 :: FunctionClass a => a -> String -> Int -> IO Function
-function_hessian__3 x = casadi__Function__hessian__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__hessian__4" c_casadi__Function__hessian__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
-casadi__Function__hessian__4
-  :: Function -> IO Function
-casadi__Function__hessian__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__hessian__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_hessian__4 :: FunctionClass a => a -> IO Function
-function_hessian__4 x = casadi__Function__hessian__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__hessian__5" c_casadi__Function__hessian__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
-casadi__Function__hessian__5
-  :: Function -> Int -> IO Function
-casadi__Function__hessian__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__hessian__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_hessian__5 :: FunctionClass a => a -> Int -> IO Function
-function_hessian__5 x = casadi__Function__hessian__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__hessian__6" c_casadi__Function__hessian__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__hessian__6
-  :: Function -> Int -> Int -> IO Function
-casadi__Function__hessian__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__hessian__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_hessian__6 :: FunctionClass a => a -> Int -> Int -> IO Function
-function_hessian__6 x = casadi__Function__hessian__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__inputDescription" c_casadi__Function__inputDescription
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString)
-casadi__Function__inputDescription
-  :: Function -> Int -> IO String
-casadi__Function__inputDescription x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__inputDescription errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_inputDescription :: FunctionClass a => a -> Int -> IO String
-function_inputDescription x = casadi__Function__inputDescription (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__inputIndex" c_casadi__Function__inputIndex
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
-casadi__Function__inputIndex
-  :: Function -> String -> IO Int
-casadi__Function__inputIndex x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__inputIndex errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_inputIndex :: FunctionClass a => a -> String -> IO Int
-function_inputIndex x = casadi__Function__inputIndex (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__inputName" c_casadi__Function__inputName
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString)
-casadi__Function__inputName
-  :: Function -> Int -> IO String
-casadi__Function__inputName x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__inputName errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_inputName :: FunctionClass a => a -> Int -> IO String
-function_inputName x = casadi__Function__inputName (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__inputScheme" c_casadi__Function__inputScheme
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString)))
-casadi__Function__inputScheme
-  :: Function -> IO (Vector String)
-casadi__Function__inputScheme x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__inputScheme errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_inputScheme :: FunctionClass a => a -> IO (Vector String)
-function_inputScheme x = casadi__Function__inputScheme (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__inputSparsity__0" c_casadi__Function__inputSparsity__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity')
-casadi__Function__inputSparsity__0
-  :: Function -> String -> IO Sparsity
-casadi__Function__inputSparsity__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__inputSparsity__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_inputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity
-function_inputSparsity__0 x = casadi__Function__inputSparsity__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__inputSparsity__1" c_casadi__Function__inputSparsity__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity')
-casadi__Function__inputSparsity__1
-  :: Function -> IO Sparsity
-casadi__Function__inputSparsity__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__inputSparsity__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_inputSparsity__1 :: FunctionClass a => a -> IO Sparsity
-function_inputSparsity__1 x = casadi__Function__inputSparsity__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__inputSparsity__2" c_casadi__Function__inputSparsity__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
-casadi__Function__inputSparsity__2
-  :: Function -> Int -> IO Sparsity
-casadi__Function__inputSparsity__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__inputSparsity__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_inputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity
-function_inputSparsity__2 x = casadi__Function__inputSparsity__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__0" c_casadi__Function__jacSparsity__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__0
-  :: Function -> String -> String -> IO Sparsity
-casadi__Function__jacSparsity__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__0 :: FunctionClass a => a -> String -> String -> IO Sparsity
-function_jacSparsity__0 x = casadi__Function__jacSparsity__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__1" c_casadi__Function__jacSparsity__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__1
-  :: Function -> String -> String -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Sparsity
-function_jacSparsity__1 x = casadi__Function__jacSparsity__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__2" c_casadi__Function__jacSparsity__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__2
-  :: Function -> String -> String -> Bool -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Sparsity
-function_jacSparsity__2 x = casadi__Function__jacSparsity__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__3" c_casadi__Function__jacSparsity__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__3
-  :: Function -> Int -> String -> IO Sparsity
-casadi__Function__jacSparsity__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__3 :: FunctionClass a => a -> Int -> String -> IO Sparsity
-function_jacSparsity__3 x = casadi__Function__jacSparsity__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__4" c_casadi__Function__jacSparsity__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__4
-  :: Function -> Int -> String -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Sparsity
-function_jacSparsity__4 x = casadi__Function__jacSparsity__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__5" c_casadi__Function__jacSparsity__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__5
-  :: Function -> Int -> String -> Bool -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Sparsity
-function_jacSparsity__5 x = casadi__Function__jacSparsity__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__6" c_casadi__Function__jacSparsity__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__6
-  :: Function -> String -> IO Sparsity
-casadi__Function__jacSparsity__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__6 :: FunctionClass a => a -> String -> IO Sparsity
-function_jacSparsity__6 x = casadi__Function__jacSparsity__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__7" c_casadi__Function__jacSparsity__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__7
-  :: Function -> String -> Int -> IO Sparsity
-casadi__Function__jacSparsity__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__7 :: FunctionClass a => a -> String -> Int -> IO Sparsity
-function_jacSparsity__7 x = casadi__Function__jacSparsity__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__8" c_casadi__Function__jacSparsity__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__8
-  :: Function -> String -> Int -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Sparsity
-function_jacSparsity__8 x = casadi__Function__jacSparsity__8 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__9" c_casadi__Function__jacSparsity__9
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__9
-  :: Function -> String -> Int -> Bool -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__9 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__9 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Sparsity
-function_jacSparsity__9 x = casadi__Function__jacSparsity__9 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__10" c_casadi__Function__jacSparsity__10
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__10
-  :: Function -> IO Sparsity
-casadi__Function__jacSparsity__10 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__10 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__10 :: FunctionClass a => a -> IO Sparsity
-function_jacSparsity__10 x = casadi__Function__jacSparsity__10 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__11" c_casadi__Function__jacSparsity__11
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__11
-  :: Function -> Int -> IO Sparsity
-casadi__Function__jacSparsity__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__11 :: FunctionClass a => a -> Int -> IO Sparsity
-function_jacSparsity__11 x = casadi__Function__jacSparsity__11 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__12" c_casadi__Function__jacSparsity__12
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__12
-  :: Function -> Int -> Int -> IO Sparsity
-casadi__Function__jacSparsity__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__12 :: FunctionClass a => a -> Int -> Int -> IO Sparsity
-function_jacSparsity__12 x = casadi__Function__jacSparsity__12 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__13" c_casadi__Function__jacSparsity__13
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__13
-  :: Function -> Int -> Int -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Sparsity
-function_jacSparsity__13 x = casadi__Function__jacSparsity__13 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__jacSparsity__14" c_casadi__Function__jacSparsity__14
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Function__jacSparsity__14
-  :: Function -> Int -> Int -> Bool -> Bool -> IO Sparsity
-casadi__Function__jacSparsity__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacSparsity__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacSparsity__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Sparsity
-function_jacSparsity__14 x = casadi__Function__jacSparsity__14 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__0" c_casadi__Function__jacobian__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__jacobian__0
-  :: Function -> String -> String -> IO Function
-casadi__Function__jacobian__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__0 :: FunctionClass a => a -> String -> String -> IO Function
-function_jacobian__0 x = casadi__Function__jacobian__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__1" c_casadi__Function__jacobian__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__1
-  :: Function -> String -> String -> Bool -> IO Function
-casadi__Function__jacobian__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Function
-function_jacobian__1 x = casadi__Function__jacobian__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__2" c_casadi__Function__jacobian__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__2
-  :: Function -> String -> String -> Bool -> Bool -> IO Function
-casadi__Function__jacobian__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Function
-function_jacobian__2 x = casadi__Function__jacobian__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__3" c_casadi__Function__jacobian__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__jacobian__3
-  :: Function -> Int -> String -> IO Function
-casadi__Function__jacobian__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__3 :: FunctionClass a => a -> Int -> String -> IO Function
-function_jacobian__3 x = casadi__Function__jacobian__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__4" c_casadi__Function__jacobian__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__4
-  :: Function -> Int -> String -> Bool -> IO Function
-casadi__Function__jacobian__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Function
-function_jacobian__4 x = casadi__Function__jacobian__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__5" c_casadi__Function__jacobian__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__5
-  :: Function -> Int -> String -> Bool -> Bool -> IO Function
-casadi__Function__jacobian__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Function
-function_jacobian__5 x = casadi__Function__jacobian__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__6" c_casadi__Function__jacobian__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__jacobian__6
-  :: Function -> String -> IO Function
-casadi__Function__jacobian__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__6 :: FunctionClass a => a -> String -> IO Function
-function_jacobian__6 x = casadi__Function__jacobian__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__7" c_casadi__Function__jacobian__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__7
-  :: Function -> String -> Int -> IO Function
-casadi__Function__jacobian__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__7 :: FunctionClass a => a -> String -> Int -> IO Function
-function_jacobian__7 x = casadi__Function__jacobian__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__8" c_casadi__Function__jacobian__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__8
-  :: Function -> String -> Int -> Bool -> IO Function
-casadi__Function__jacobian__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Function
-function_jacobian__8 x = casadi__Function__jacobian__8 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__9" c_casadi__Function__jacobian__9
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__9
-  :: Function -> String -> Int -> Bool -> Bool -> IO Function
-casadi__Function__jacobian__9 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__9 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Function
-function_jacobian__9 x = casadi__Function__jacobian__9 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__10" c_casadi__Function__jacobian__10
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
-casadi__Function__jacobian__10
-  :: Function -> IO Function
-casadi__Function__jacobian__10 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__10 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__10 :: FunctionClass a => a -> IO Function
-function_jacobian__10 x = casadi__Function__jacobian__10 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__11" c_casadi__Function__jacobian__11
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__11
-  :: Function -> Int -> IO Function
-casadi__Function__jacobian__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__11 :: FunctionClass a => a -> Int -> IO Function
-function_jacobian__11 x = casadi__Function__jacobian__11 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__12" c_casadi__Function__jacobian__12
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__12
-  :: Function -> Int -> Int -> IO Function
-casadi__Function__jacobian__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__12 :: FunctionClass a => a -> Int -> Int -> IO Function
-function_jacobian__12 x = casadi__Function__jacobian__12 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__13" c_casadi__Function__jacobian__13
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__13
-  :: Function -> Int -> Int -> Bool -> IO Function
-casadi__Function__jacobian__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Function
-function_jacobian__13 x = casadi__Function__jacobian__13 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__jacobian__14" c_casadi__Function__jacobian__14
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__jacobian__14
-  :: Function -> Int -> Int -> Bool -> Bool -> IO Function
-casadi__Function__jacobian__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__jacobian__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_jacobian__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Function
-function_jacobian__14 x = casadi__Function__jacobian__14 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__map__0" c_casadi__Function__map__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__map__0
-  :: Function -> String -> Int -> IO Function
-casadi__Function__map__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__map__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_map__0 :: FunctionClass a => a -> String -> Int -> IO Function
-function_map__0 x = casadi__Function__map__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__map__1" c_casadi__Function__map__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
-casadi__Function__map__1
-  :: Function -> String -> Int -> M.Map String GenericType -> IO Function
-casadi__Function__map__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__map__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_map__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function
-function_map__1 x = casadi__Function__map__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__map__2" c_casadi__Function__map__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__map__2
-  :: Function -> Vector MX -> IO (Vector MX)
-casadi__Function__map__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__map__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_map__2 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
-function_map__2 x = casadi__Function__map__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__map__3" c_casadi__Function__map__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__map__3
-  :: Function -> Vector MX -> String -> IO (Vector MX)
-casadi__Function__map__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__map__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_map__3 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX)
-function_map__3 x = casadi__Function__map__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__map__4" c_casadi__Function__map__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi__Function__map__4
-  :: Function -> Vector (Vector MX) -> IO (Vector (Vector MX))
-casadi__Function__map__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__map__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_map__4 :: FunctionClass a => a -> Vector (Vector MX) -> IO (Vector (Vector MX))
-function_map__4 x = casadi__Function__map__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__map__5" c_casadi__Function__map__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi__Function__map__5
-  :: Function -> Vector (Vector MX) -> String -> IO (Vector (Vector MX))
-casadi__Function__map__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__map__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_map__5 :: FunctionClass a => a -> Vector (Vector MX) -> String -> IO (Vector (Vector MX))
-function_map__5 x = casadi__Function__map__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__mapaccum__0" c_casadi__Function__mapaccum__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__mapaccum__0
-  :: Function -> String -> Int -> IO Function
-casadi__Function__mapaccum__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__mapaccum__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_mapaccum__0 :: FunctionClass a => a -> String -> Int -> IO Function
-function_mapaccum__0 x = casadi__Function__mapaccum__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__mapaccum__1" c_casadi__Function__mapaccum__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
-casadi__Function__mapaccum__1
-  :: Function -> String -> Int -> M.Map String GenericType -> IO Function
-casadi__Function__mapaccum__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__mapaccum__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_mapaccum__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function
-function_mapaccum__1 x = casadi__Function__mapaccum__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__mapsum__0" c_casadi__Function__mapsum__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__mapsum__0
-  :: Function -> Vector MX -> IO (Vector MX)
-casadi__Function__mapsum__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__mapsum__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_mapsum__0 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
-function_mapsum__0 x = casadi__Function__mapsum__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__mapsum__1" c_casadi__Function__mapsum__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__mapsum__1
-  :: Function -> Vector MX -> String -> IO (Vector MX)
-casadi__Function__mapsum__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__mapsum__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_mapsum__1 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX)
-function_mapsum__1 x = casadi__Function__mapsum__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__nIn" c_casadi__Function__nIn
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
-casadi__Function__nIn
-  :: Function -> IO Int
-casadi__Function__nIn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__nIn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_nIn :: FunctionClass a => a -> IO Int
-function_nIn x = casadi__Function__nIn (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__nOut" c_casadi__Function__nOut
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
-casadi__Function__nOut
-  :: Function -> IO Int
-casadi__Function__nOut x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__nOut errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_nOut :: FunctionClass a => a -> IO Int
-function_nOut x = casadi__Function__nOut (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__nnzIn" c_casadi__Function__nnzIn
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
-casadi__Function__nnzIn
-  :: Function -> IO Int
-casadi__Function__nnzIn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__nnzIn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_nnzIn :: FunctionClass a => a -> IO Int
-function_nnzIn x = casadi__Function__nnzIn (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__nnzOut" c_casadi__Function__nnzOut
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
-casadi__Function__nnzOut
-  :: Function -> IO Int
-casadi__Function__nnzOut x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__nnzOut errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_nnzOut :: FunctionClass a => a -> IO Int
-function_nnzOut x = casadi__Function__nnzOut (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__numelIn" c_casadi__Function__numelIn
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
-casadi__Function__numelIn
-  :: Function -> IO Int
-casadi__Function__numelIn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__numelIn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_numelIn :: FunctionClass a => a -> IO Int
-function_numelIn x = casadi__Function__numelIn (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__numelOut" c_casadi__Function__numelOut
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
-casadi__Function__numelOut
-  :: Function -> IO Int
-casadi__Function__numelOut x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__numelOut errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_numelOut :: FunctionClass a => a -> IO Int
-function_numelOut x = casadi__Function__numelOut (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__0" c_casadi__Function__operator_call__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr (StdMap StdString (Ptr MX')))
-casadi__Function__operator_call__0
-  :: Function -> M.Map String MX -> IO (M.Map String MX)
-casadi__Function__operator_call__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__0 :: FunctionClass a => a -> M.Map String MX -> IO (M.Map String MX)
-function_operator_call__0 x = casadi__Function__operator_call__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__1" c_casadi__Function__operator_call__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> CInt -> IO (Ptr (StdMap StdString (Ptr MX')))
-casadi__Function__operator_call__1
-  :: Function -> M.Map String MX -> Bool -> IO (M.Map String MX)
-casadi__Function__operator_call__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__1 :: FunctionClass a => a -> M.Map String MX -> Bool -> IO (M.Map String MX)
-function_operator_call__1 x = casadi__Function__operator_call__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__2" c_casadi__Function__operator_call__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr MX')))
-casadi__Function__operator_call__2
-  :: Function -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX)
-casadi__Function__operator_call__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__2 :: FunctionClass a => a -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX)
-function_operator_call__2 x = casadi__Function__operator_call__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__3" c_casadi__Function__operator_call__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr (StdMap StdString (Ptr SX')))
-casadi__Function__operator_call__3
-  :: Function -> M.Map String SX -> IO (M.Map String SX)
-casadi__Function__operator_call__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__3 :: FunctionClass a => a -> M.Map String SX -> IO (M.Map String SX)
-function_operator_call__3 x = casadi__Function__operator_call__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__4" c_casadi__Function__operator_call__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> CInt -> IO (Ptr (StdMap StdString (Ptr SX')))
-casadi__Function__operator_call__4
-  :: Function -> M.Map String SX -> Bool -> IO (M.Map String SX)
-casadi__Function__operator_call__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__4 :: FunctionClass a => a -> M.Map String SX -> Bool -> IO (M.Map String SX)
-function_operator_call__4 x = casadi__Function__operator_call__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__5" c_casadi__Function__operator_call__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr SX')))
-casadi__Function__operator_call__5
-  :: Function -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX)
-casadi__Function__operator_call__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__5 :: FunctionClass a => a -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX)
-function_operator_call__5 x = casadi__Function__operator_call__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__6" c_casadi__Function__operator_call__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> IO (Ptr (StdMap StdString (Ptr DMatrix')))
-casadi__Function__operator_call__6
-  :: Function -> M.Map String DMatrix -> IO (M.Map String DMatrix)
-casadi__Function__operator_call__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__6 :: FunctionClass a => a -> M.Map String DMatrix -> IO (M.Map String DMatrix)
-function_operator_call__6 x = casadi__Function__operator_call__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__7" c_casadi__Function__operator_call__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> CInt -> IO (Ptr (StdMap StdString (Ptr DMatrix')))
-casadi__Function__operator_call__7
-  :: Function -> M.Map String DMatrix -> Bool -> IO (M.Map String DMatrix)
-casadi__Function__operator_call__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__7 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> IO (M.Map String DMatrix)
-function_operator_call__7 x = casadi__Function__operator_call__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__8" c_casadi__Function__operator_call__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr DMatrix')))
-casadi__Function__operator_call__8
-  :: Function -> M.Map String DMatrix -> Bool -> Bool -> IO (M.Map String DMatrix)
-casadi__Function__operator_call__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__8 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> Bool -> IO (M.Map String DMatrix)
-function_operator_call__8 x = casadi__Function__operator_call__8 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__9" c_casadi__Function__operator_call__9
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__operator_call__9
-  :: Function -> Vector MX -> IO (Vector MX)
-casadi__Function__operator_call__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__9 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
-function_operator_call__9 x = casadi__Function__operator_call__9 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__10" c_casadi__Function__operator_call__10
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__operator_call__10
-  :: Function -> Vector MX -> Bool -> IO (Vector MX)
-casadi__Function__operator_call__10 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__10 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__10 :: FunctionClass a => a -> Vector MX -> Bool -> IO (Vector MX)
-function_operator_call__10 x = casadi__Function__operator_call__10 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__11" c_casadi__Function__operator_call__11
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__operator_call__11
-  :: Function -> Vector MX -> Bool -> Bool -> IO (Vector MX)
-casadi__Function__operator_call__11 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__11 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__11 :: FunctionClass a => a -> Vector MX -> Bool -> Bool -> IO (Vector MX)
-function_operator_call__11 x = casadi__Function__operator_call__11 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__12" c_casadi__Function__operator_call__12
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
-casadi__Function__operator_call__12
-  :: Function -> Vector SX -> IO (Vector SX)
-casadi__Function__operator_call__12 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__12 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__12 :: FunctionClass a => a -> Vector SX -> IO (Vector SX)
-function_operator_call__12 x = casadi__Function__operator_call__12 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__13" c_casadi__Function__operator_call__13
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi__Function__operator_call__13
-  :: Function -> Vector SX -> Bool -> IO (Vector SX)
-casadi__Function__operator_call__13 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__13 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__13 :: FunctionClass a => a -> Vector SX -> Bool -> IO (Vector SX)
-function_operator_call__13 x = casadi__Function__operator_call__13 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__14" c_casadi__Function__operator_call__14
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi__Function__operator_call__14
-  :: Function -> Vector SX -> Bool -> Bool -> IO (Vector SX)
-casadi__Function__operator_call__14 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__14 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__14 :: FunctionClass a => a -> Vector SX -> Bool -> Bool -> IO (Vector SX)
-function_operator_call__14 x = casadi__Function__operator_call__14 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__15" c_casadi__Function__operator_call__15
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi__Function__operator_call__15
-  :: Function -> Vector DMatrix -> IO (Vector DMatrix)
-casadi__Function__operator_call__15 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__15 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__15 :: FunctionClass a => a -> Vector DMatrix -> IO (Vector DMatrix)
-function_operator_call__15 x = casadi__Function__operator_call__15 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__16" c_casadi__Function__operator_call__16
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi__Function__operator_call__16
-  :: Function -> Vector DMatrix -> Bool -> IO (Vector DMatrix)
-casadi__Function__operator_call__16 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__16 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__16 :: FunctionClass a => a -> Vector DMatrix -> Bool -> IO (Vector DMatrix)
-function_operator_call__16 x = casadi__Function__operator_call__16 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__operator_call__17" c_casadi__Function__operator_call__17
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi__Function__operator_call__17
-  :: Function -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix)
-casadi__Function__operator_call__17 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__operator_call__17 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_operator_call__17 :: FunctionClass a => a -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix)
-function_operator_call__17 x = casadi__Function__operator_call__17 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__outputDescription" c_casadi__Function__outputDescription
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString)
-casadi__Function__outputDescription
-  :: Function -> Int -> IO String
-casadi__Function__outputDescription x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__outputDescription errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_outputDescription :: FunctionClass a => a -> Int -> IO String
-function_outputDescription x = casadi__Function__outputDescription (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__outputIndex" c_casadi__Function__outputIndex
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
-casadi__Function__outputIndex
-  :: Function -> String -> IO Int
-casadi__Function__outputIndex x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__outputIndex errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_outputIndex :: FunctionClass a => a -> String -> IO Int
-function_outputIndex x = casadi__Function__outputIndex (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__outputName" c_casadi__Function__outputName
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString)
-casadi__Function__outputName
-  :: Function -> Int -> IO String
-casadi__Function__outputName x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__outputName errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_outputName :: FunctionClass a => a -> Int -> IO String
-function_outputName x = casadi__Function__outputName (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__outputScheme" c_casadi__Function__outputScheme
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString)))
-casadi__Function__outputScheme
-  :: Function -> IO (Vector String)
-casadi__Function__outputScheme x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__outputScheme errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_outputScheme :: FunctionClass a => a -> IO (Vector String)
-function_outputScheme x = casadi__Function__outputScheme (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__outputSparsity__0" c_casadi__Function__outputSparsity__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity')
-casadi__Function__outputSparsity__0
-  :: Function -> String -> IO Sparsity
-casadi__Function__outputSparsity__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__outputSparsity__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_outputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity
-function_outputSparsity__0 x = casadi__Function__outputSparsity__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__outputSparsity__1" c_casadi__Function__outputSparsity__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity')
-casadi__Function__outputSparsity__1
-  :: Function -> IO Sparsity
-casadi__Function__outputSparsity__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__outputSparsity__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_outputSparsity__1 :: FunctionClass a => a -> IO Sparsity
-function_outputSparsity__1 x = casadi__Function__outputSparsity__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__outputSparsity__2" c_casadi__Function__outputSparsity__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
-casadi__Function__outputSparsity__2
-  :: Function -> Int -> IO Sparsity
-casadi__Function__outputSparsity__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__outputSparsity__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_outputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity
-function_outputSparsity__2 x = casadi__Function__outputSparsity__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__printDimensions" c_casadi__Function__printDimensions
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
-casadi__Function__printDimensions
-  :: Function -> IO ()
-casadi__Function__printDimensions x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__printDimensions errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_printDimensions :: FunctionClass a => a -> IO ()
-function_printDimensions x = casadi__Function__printDimensions (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__removeMonitor" c_casadi__Function__removeMonitor
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
-casadi__Function__removeMonitor
-  :: Function -> String -> IO ()
-casadi__Function__removeMonitor x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__removeMonitor errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_removeMonitor :: FunctionClass a => a -> String -> IO ()
-function_removeMonitor x = casadi__Function__removeMonitor (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__sanitizeName" c_casadi__Function__sanitizeName
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__Function__sanitizeName
-  :: String -> IO String
-casadi__Function__sanitizeName x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__sanitizeName errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_sanitizeName :: String -> IO String
-function_sanitizeName = casadi__Function__sanitizeName
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setDerForward" c_casadi__Function__setDerForward
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO ()
-casadi__Function__setDerForward
-  :: Function -> Function -> Int -> IO ()
-casadi__Function__setDerForward x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setDerForward errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setDerForward :: FunctionClass a => a -> Function -> Int -> IO ()
-function_setDerForward x = casadi__Function__setDerForward (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setDerReverse" c_casadi__Function__setDerReverse
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO ()
-casadi__Function__setDerReverse
-  :: Function -> Function -> Int -> IO ()
-casadi__Function__setDerReverse x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setDerReverse errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setDerReverse :: FunctionClass a => a -> Function -> Int -> IO ()
-function_setDerReverse x = casadi__Function__setDerReverse (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setFullJacobian" c_casadi__Function__setFullJacobian
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO ()
-casadi__Function__setFullJacobian
-  :: Function -> Function -> IO ()
-casadi__Function__setFullJacobian x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setFullJacobian errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setFullJacobian :: FunctionClass a => a -> Function -> IO ()
-function_setFullJacobian x = casadi__Function__setFullJacobian (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__0" c_casadi__Function__setJacSparsity__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> IO ()
-casadi__Function__setJacSparsity__0
-  :: Function -> Sparsity -> String -> String -> IO ()
-casadi__Function__setJacSparsity__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__0 :: FunctionClass a => a -> Sparsity -> String -> String -> IO ()
-function_setJacSparsity__0 x = casadi__Function__setJacSparsity__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__1" c_casadi__Function__setJacSparsity__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> CInt -> IO ()
-casadi__Function__setJacSparsity__1
-  :: Function -> Sparsity -> String -> String -> Bool -> IO ()
-casadi__Function__setJacSparsity__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__1 :: FunctionClass a => a -> Sparsity -> String -> String -> Bool -> IO ()
-function_setJacSparsity__1 x = casadi__Function__setJacSparsity__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__2" c_casadi__Function__setJacSparsity__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> IO ()
-casadi__Function__setJacSparsity__2
-  :: Function -> Sparsity -> Int -> String -> IO ()
-casadi__Function__setJacSparsity__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__2 :: FunctionClass a => a -> Sparsity -> Int -> String -> IO ()
-function_setJacSparsity__2 x = casadi__Function__setJacSparsity__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__3" c_casadi__Function__setJacSparsity__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> CInt -> IO ()
-casadi__Function__setJacSparsity__3
-  :: Function -> Sparsity -> Int -> String -> Bool -> IO ()
-casadi__Function__setJacSparsity__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__3 :: FunctionClass a => a -> Sparsity -> Int -> String -> Bool -> IO ()
-function_setJacSparsity__3 x = casadi__Function__setJacSparsity__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__4" c_casadi__Function__setJacSparsity__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> IO ()
-casadi__Function__setJacSparsity__4
-  :: Function -> Sparsity -> String -> Int -> IO ()
-casadi__Function__setJacSparsity__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__4 :: FunctionClass a => a -> Sparsity -> String -> Int -> IO ()
-function_setJacSparsity__4 x = casadi__Function__setJacSparsity__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__5" c_casadi__Function__setJacSparsity__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> CInt -> IO ()
-casadi__Function__setJacSparsity__5
-  :: Function -> Sparsity -> String -> Int -> Bool -> IO ()
-casadi__Function__setJacSparsity__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__5 :: FunctionClass a => a -> Sparsity -> String -> Int -> Bool -> IO ()
-function_setJacSparsity__5 x = casadi__Function__setJacSparsity__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__6" c_casadi__Function__setJacSparsity__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> IO ()
-casadi__Function__setJacSparsity__6
-  :: Function -> Sparsity -> Int -> Int -> IO ()
-casadi__Function__setJacSparsity__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__6 :: FunctionClass a => a -> Sparsity -> Int -> Int -> IO ()
-function_setJacSparsity__6 x = casadi__Function__setJacSparsity__6 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacSparsity__7" c_casadi__Function__setJacSparsity__7
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> CInt -> IO ()
-casadi__Function__setJacSparsity__7
-  :: Function -> Sparsity -> Int -> Int -> Bool -> IO ()
-casadi__Function__setJacSparsity__7 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacSparsity__7 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacSparsity__7 :: FunctionClass a => a -> Sparsity -> Int -> Int -> Bool -> IO ()
-function_setJacSparsity__7 x = casadi__Function__setJacSparsity__7 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacobian__0" c_casadi__Function__setJacobian__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO ()
-casadi__Function__setJacobian__0
-  :: Function -> Function -> IO ()
-casadi__Function__setJacobian__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacobian__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacobian__0 :: FunctionClass a => a -> Function -> IO ()
-function_setJacobian__0 x = casadi__Function__setJacobian__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacobian__1" c_casadi__Function__setJacobian__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO ()
-casadi__Function__setJacobian__1
-  :: Function -> Function -> Int -> IO ()
-casadi__Function__setJacobian__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacobian__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacobian__1 :: FunctionClass a => a -> Function -> Int -> IO ()
-function_setJacobian__1 x = casadi__Function__setJacobian__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacobian__2" c_casadi__Function__setJacobian__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> IO ()
-casadi__Function__setJacobian__2
-  :: Function -> Function -> Int -> Int -> IO ()
-casadi__Function__setJacobian__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacobian__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacobian__2 :: FunctionClass a => a -> Function -> Int -> Int -> IO ()
-function_setJacobian__2 x = casadi__Function__setJacobian__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__setJacobian__3" c_casadi__Function__setJacobian__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> CInt -> IO ()
-casadi__Function__setJacobian__3
-  :: Function -> Function -> Int -> Int -> Bool -> IO ()
-casadi__Function__setJacobian__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__setJacobian__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_setJacobian__3 :: FunctionClass a => a -> Function -> Int -> Int -> Bool -> IO ()
-function_setJacobian__3 x = casadi__Function__setJacobian__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__spCanEvaluate" c_casadi__Function__spCanEvaluate
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
-casadi__Function__spCanEvaluate
-  :: Function -> Bool -> IO Bool
-casadi__Function__spCanEvaluate x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__spCanEvaluate errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_spCanEvaluate :: FunctionClass a => a -> Bool -> IO Bool
-function_spCanEvaluate x = casadi__Function__spCanEvaluate (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__spEvaluate" c_casadi__Function__spEvaluate
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO ()
-casadi__Function__spEvaluate
-  :: Function -> Bool -> IO ()
-casadi__Function__spEvaluate x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__spEvaluate errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_spEvaluate :: FunctionClass a => a -> Bool -> IO ()
-function_spEvaluate x = casadi__Function__spEvaluate (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__spInit" c_casadi__Function__spInit
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO ()
-casadi__Function__spInit
-  :: Function -> Bool -> IO ()
-casadi__Function__spInit x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__spInit errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_spInit :: FunctionClass a => a -> Bool -> IO ()
-function_spInit x = casadi__Function__spInit (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__symbolicInput__0" c_casadi__Function__symbolicInput__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__symbolicInput__0
-  :: Function -> IO (Vector MX)
-casadi__Function__symbolicInput__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__symbolicInput__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_symbolicInput__0 :: FunctionClass a => a -> IO (Vector MX)
-function_symbolicInput__0 x = casadi__Function__symbolicInput__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__symbolicInput__1" c_casadi__Function__symbolicInput__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__symbolicInput__1
-  :: Function -> Bool -> IO (Vector MX)
-casadi__Function__symbolicInput__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__symbolicInput__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_symbolicInput__1 :: FunctionClass a => a -> Bool -> IO (Vector MX)
-function_symbolicInput__1 x = casadi__Function__symbolicInput__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__symbolicInputSX" c_casadi__Function__symbolicInputSX
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX')))
-casadi__Function__symbolicInputSX
-  :: Function -> IO (Vector SX)
-casadi__Function__symbolicInputSX x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__symbolicInputSX errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_symbolicInputSX :: FunctionClass a => a -> IO (Vector SX)
-function_symbolicInputSX x = casadi__Function__symbolicInputSX (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__symbolicOutput" c_casadi__Function__symbolicOutput
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX')))
-casadi__Function__symbolicOutput
-  :: Function -> IO (Vector MX)
-casadi__Function__symbolicOutput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__symbolicOutput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_symbolicOutput :: FunctionClass a => a -> IO (Vector MX)
-function_symbolicOutput x = casadi__Function__symbolicOutput (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__sz_arg" c_casadi__Function__sz_arg
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
-casadi__Function__sz_arg
-  :: Function -> IO CSize
-casadi__Function__sz_arg x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__sz_arg errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_sz_arg :: FunctionClass a => a -> IO CSize
-function_sz_arg x = casadi__Function__sz_arg (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__sz_iw" c_casadi__Function__sz_iw
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
-casadi__Function__sz_iw
-  :: Function -> IO CSize
-casadi__Function__sz_iw x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__sz_iw errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_sz_iw :: FunctionClass a => a -> IO CSize
-function_sz_iw x = casadi__Function__sz_iw (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__sz_res" c_casadi__Function__sz_res
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
-casadi__Function__sz_res
-  :: Function -> IO CSize
-casadi__Function__sz_res x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__sz_res errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_sz_res :: FunctionClass a => a -> IO CSize
-function_sz_res x = casadi__Function__sz_res (castFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Function__sz_w" c_casadi__Function__sz_w
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
-casadi__Function__sz_w
-  :: Function -> IO CSize
-casadi__Function__sz_w x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__sz_w errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_sz_w :: FunctionClass a => a -> IO CSize
-function_sz_w x = casadi__Function__sz_w (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__tangent__0" c_casadi__Function__tangent__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__tangent__0
-  :: Function -> String -> String -> IO Function
-casadi__Function__tangent__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__tangent__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_tangent__0 :: FunctionClass a => a -> String -> String -> IO Function
-function_tangent__0 x = casadi__Function__tangent__0 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__tangent__1" c_casadi__Function__tangent__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__tangent__1
-  :: Function -> Int -> String -> IO Function
-casadi__Function__tangent__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__tangent__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_tangent__1 :: FunctionClass a => a -> Int -> String -> IO Function
-function_tangent__1 x = casadi__Function__tangent__1 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__tangent__2" c_casadi__Function__tangent__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
-casadi__Function__tangent__2
-  :: Function -> String -> IO Function
-casadi__Function__tangent__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__tangent__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_tangent__2 :: FunctionClass a => a -> String -> IO Function
-function_tangent__2 x = casadi__Function__tangent__2 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__tangent__3" c_casadi__Function__tangent__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
-casadi__Function__tangent__3
-  :: Function -> String -> Int -> IO Function
-casadi__Function__tangent__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__tangent__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_tangent__3 :: FunctionClass a => a -> String -> Int -> IO Function
-function_tangent__3 x = casadi__Function__tangent__3 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__tangent__4" c_casadi__Function__tangent__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
-casadi__Function__tangent__4
-  :: Function -> IO Function
-casadi__Function__tangent__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__tangent__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_tangent__4 :: FunctionClass a => a -> IO Function
-function_tangent__4 x = casadi__Function__tangent__4 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__tangent__5" c_casadi__Function__tangent__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
-casadi__Function__tangent__5
-  :: Function -> Int -> IO Function
-casadi__Function__tangent__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__tangent__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_tangent__5 :: FunctionClass a => a -> Int -> IO Function
-function_tangent__5 x = casadi__Function__tangent__5 (castFunction x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__Function__tangent__6" c_casadi__Function__tangent__6
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
-casadi__Function__tangent__6
-  :: Function -> Int -> Int -> IO Function
-casadi__Function__tangent__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Function__tangent__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-function_tangent__6 :: FunctionClass a => a -> Int -> Int -> IO Function
-function_tangent__6 x = casadi__Function__tangent__6 (castFunction x)
+         function__0,
+         function__1,
+         function__10,
+         function__11,
+         function__12,
+         function__13,
+         function__2,
+         function__3,
+         function__4,
+         function__5,
+         function__6,
+         function__7,
+         function__8,
+         function__9,
+         function_addMonitor,
+         function_call__0,
+         function_call__1,
+         function_call__10,
+         function_call__11,
+         function_call__12,
+         function_call__13,
+         function_call__14,
+         function_call__15,
+         function_call__16,
+         function_call__17,
+         function_call__2,
+         function_call__3,
+         function_call__4,
+         function_call__5,
+         function_call__6,
+         function_call__7,
+         function_call__8,
+         function_call__9,
+         function_checkInputs,
+         function_check_name,
+         function_checkout,
+         function_conditional__0,
+         function_conditional__1,
+         function_default_in,
+         function_derivative__0,
+         function_derivative__1,
+         function_derivative__2,
+         function_derivative__3,
+         function_derivative__4,
+         function_derivative__5,
+         function_derivative__6,
+         function_derivative__7,
+         function_derivative__8,
+         function_derivative__9,
+         function_expand__0,
+         function_expand__1,
+         function_expand__2,
+         function_fix_name,
+         function_forward__0,
+         function_forward__1,
+         function_forward__2,
+         function_forward__3,
+         function_forward__4,
+         function_forward__5,
+         function_forward__6,
+         function_forward__7,
+         function_forward__8,
+         function_forward__9,
+         function_free_mx,
+         function_free_sx,
+         function_fullJacobian,
+         function_generate__0,
+         function_generate__1,
+         function_generate__2,
+         function_generate__3,
+         function_generate_dependencies__0,
+         function_generate_dependencies__1,
+         function_generate_lifted,
+         function_getAlgorithmSize,
+         function_getAtomicInput,
+         function_getAtomicInputReal,
+         function_getAtomicOperation,
+         function_getAtomicOutput,
+         function_getWorkSize,
+         function_gradient__0,
+         function_gradient__1,
+         function_gradient__2,
+         function_gradient__3,
+         function_gradient__4,
+         function_gradient__5,
+         function_gradient__6,
+         function_has_free,
+         function_hessian__0,
+         function_hessian__1,
+         function_hessian__2,
+         function_hessian__3,
+         function_hessian__4,
+         function_hessian__5,
+         function_hessian__6,
+         function_if_else__0,
+         function_if_else__1,
+         function_index_in,
+         function_index_out,
+         function_integrator_dae,
+         function_is_a__0,
+         function_is_a__1,
+         function_jacobian__0,
+         function_jacobian__1,
+         function_jacobian__10,
+         function_jacobian__11,
+         function_jacobian__12,
+         function_jacobian__13,
+         function_jacobian__14,
+         function_jacobian__2,
+         function_jacobian__3,
+         function_jacobian__4,
+         function_jacobian__5,
+         function_jacobian__6,
+         function_jacobian__7,
+         function_jacobian__8,
+         function_jacobian__9,
+         function_kernel_sum__0,
+         function_kernel_sum__1,
+         function_linsol_cholesky__0,
+         function_linsol_cholesky__1,
+         function_linsol_cholesky__2,
+         function_linsol_cholesky_sparsity__0,
+         function_linsol_cholesky_sparsity__1,
+         function_linsol_cholesky_sparsity__2,
+         function_linsol_solve__0,
+         function_linsol_solve__1,
+         function_map__0,
+         function_map__1,
+         function_map__2,
+         function_map__3,
+         function_map__4,
+         function_map__5,
+         function_map__6,
+         function_map__7,
+         function_mapaccum__0,
+         function_mapaccum__1,
+         function_mapaccum__2,
+         function_mapaccum__3,
+         function_mapsum__0,
+         function_mapsum__1,
+         function_mx_in__0,
+         function_mx_in__1,
+         function_mx_in__2,
+         function_mx_out__0,
+         function_mx_out__1,
+         function_mx_out__2,
+         function_n_in,
+         function_n_nodes,
+         function_n_out,
+         function_name,
+         function_name_in__0,
+         function_name_in__1,
+         function_name_out__0,
+         function_name_out__1,
+         function_nnz_in__0,
+         function_nnz_in__1,
+         function_nnz_in__2,
+         function_nnz_out__0,
+         function_nnz_out__1,
+         function_nnz_out__2,
+         function_numel_in__0,
+         function_numel_in__1,
+         function_numel_in__2,
+         function_numel_out__0,
+         function_numel_out__1,
+         function_numel_out__2,
+         function_printDimensions,
+         function_printOption,
+         function_printOptions,
+         function_qpsol_debug,
+         function_release,
+         function_removeMonitor,
+         function_reverse__0,
+         function_reverse__1,
+         function_reverse__2,
+         function_reverse__3,
+         function_reverse__4,
+         function_reverse__5,
+         function_reverse__6,
+         function_reverse__7,
+         function_reverse__8,
+         function_reverse__9,
+         function_rootfinder_fun,
+         function_rootfinder_jac,
+         function_rootfinder_linsol,
+         function_setFullJacobian,
+         function_setJacobian__0,
+         function_setJacobian__1,
+         function_setJacobian__2,
+         function_setJacobian__3,
+         function_set_forward,
+         function_set_jac_sparsity__0,
+         function_set_jac_sparsity__1,
+         function_set_jac_sparsity__2,
+         function_set_jac_sparsity__3,
+         function_set_jac_sparsity__4,
+         function_set_jac_sparsity__5,
+         function_set_jac_sparsity__6,
+         function_set_jac_sparsity__7,
+         function_set_reverse,
+         function_size1_in__0,
+         function_size1_in__1,
+         function_size1_out__0,
+         function_size1_out__1,
+         function_size2_in__0,
+         function_size2_in__1,
+         function_size2_out__0,
+         function_size2_out__1,
+         function_size_in__0,
+         function_size_in__1,
+         function_size_out__0,
+         function_size_out__1,
+         function_slice__0,
+         function_slice__1,
+         function_spCanEvaluate,
+         function_sparsity_in__0,
+         function_sparsity_in__1,
+         function_sparsity_jac__0,
+         function_sparsity_jac__1,
+         function_sparsity_jac__10,
+         function_sparsity_jac__11,
+         function_sparsity_jac__12,
+         function_sparsity_jac__13,
+         function_sparsity_jac__14,
+         function_sparsity_jac__2,
+         function_sparsity_jac__3,
+         function_sparsity_jac__4,
+         function_sparsity_jac__5,
+         function_sparsity_jac__6,
+         function_sparsity_jac__7,
+         function_sparsity_jac__8,
+         function_sparsity_jac__9,
+         function_sparsity_out__0,
+         function_sparsity_out__1,
+         function_stats__0,
+         function_stats__1,
+         function_sx_in__0,
+         function_sx_in__1,
+         function_sx_in__2,
+         function_sx_out__0,
+         function_sx_out__1,
+         function_sx_out__2,
+         function_sz_arg,
+         function_sz_iw,
+         function_sz_res,
+         function_sz_w,
+         function_tangent__0,
+         function_tangent__1,
+         function_tangent__2,
+         function_tangent__3,
+         function_tangent__4,
+         function_tangent__5,
+         function_tangent__6,
+         function_type_name,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__0" c_casadi__Function__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__0
+  :: String -> M.Map String MX -> Vector String -> Vector String -> IO Function
+casadi__Function__CONSTRUCTOR__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function__0 :: String -> M.Map String MX -> Vector String -> Vector String -> IO Function
+function__0 = casadi__Function__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__1" c_casadi__Function__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__1
+  :: String -> M.Map String MX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+casadi__Function__CONSTRUCTOR__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function__1 :: String -> M.Map String MX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+function__1 = casadi__Function__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__2" c_casadi__Function__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__2
+  :: String -> Vector MX -> Vector MX -> Vector String -> Vector String -> IO Function
+casadi__Function__CONSTRUCTOR__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function__2 :: String -> Vector MX -> Vector MX -> Vector String -> Vector String -> IO Function
+function__2 = casadi__Function__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__3" c_casadi__Function__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__3
+  :: String -> Vector MX -> Vector MX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+casadi__Function__CONSTRUCTOR__3 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+-- classy wrapper
+function__3 :: String -> Vector MX -> Vector MX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+function__3 = casadi__Function__CONSTRUCTOR__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__4" c_casadi__Function__CONSTRUCTOR__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__4
+  :: String -> Vector MX -> Vector MX -> IO Function
+casadi__Function__CONSTRUCTOR__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function__4 :: String -> Vector MX -> Vector MX -> IO Function
+function__4 = casadi__Function__CONSTRUCTOR__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__5" c_casadi__Function__CONSTRUCTOR__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__5
+  :: String -> Vector MX -> Vector MX -> M.Map String GenericType -> IO Function
+casadi__Function__CONSTRUCTOR__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function__5 :: String -> Vector MX -> Vector MX -> M.Map String GenericType -> IO Function
+function__5 = casadi__Function__CONSTRUCTOR__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__6" c_casadi__Function__CONSTRUCTOR__6
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__6
+  :: String -> M.Map String SX -> Vector String -> Vector String -> IO Function
+casadi__Function__CONSTRUCTOR__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function__6 :: String -> M.Map String SX -> Vector String -> Vector String -> IO Function
+function__6 = casadi__Function__CONSTRUCTOR__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__7" c_casadi__Function__CONSTRUCTOR__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__7
+  :: String -> M.Map String SX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+casadi__Function__CONSTRUCTOR__7 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function__7 :: String -> M.Map String SX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+function__7 = casadi__Function__CONSTRUCTOR__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__8" c_casadi__Function__CONSTRUCTOR__8
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__8
+  :: String -> Vector SX -> Vector SX -> Vector String -> Vector String -> IO Function
+casadi__Function__CONSTRUCTOR__8 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__8 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function__8 :: String -> Vector SX -> Vector SX -> Vector String -> Vector String -> IO Function
+function__8 = casadi__Function__CONSTRUCTOR__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__9" c_casadi__Function__CONSTRUCTOR__9
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__9
+  :: String -> Vector SX -> Vector SX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+casadi__Function__CONSTRUCTOR__9 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__9 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+-- classy wrapper
+function__9 :: String -> Vector SX -> Vector SX -> Vector String -> Vector String -> M.Map String GenericType -> IO Function
+function__9 = casadi__Function__CONSTRUCTOR__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__10" c_casadi__Function__CONSTRUCTOR__10
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__10
+  :: String -> Vector SX -> Vector SX -> IO Function
+casadi__Function__CONSTRUCTOR__10 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__10 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function__10 :: String -> Vector SX -> Vector SX -> IO Function
+function__10 = casadi__Function__CONSTRUCTOR__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__11" c_casadi__Function__CONSTRUCTOR__11
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__11
+  :: String -> Vector SX -> Vector SX -> M.Map String GenericType -> IO Function
+casadi__Function__CONSTRUCTOR__11 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__11 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function__11 :: String -> Vector SX -> Vector SX -> M.Map String GenericType -> IO Function
+function__11 = casadi__Function__CONSTRUCTOR__11
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__12" c_casadi__Function__CONSTRUCTOR__12
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__12
+  :: String -> IO Function
+casadi__Function__CONSTRUCTOR__12 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__12 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function__12 :: String -> IO Function
+function__12 = casadi__Function__CONSTRUCTOR__12
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__CONSTRUCTOR__13" c_casadi__Function__CONSTRUCTOR__13
+  :: Ptr (Ptr StdString) -> IO (Ptr Function')
+
+casadi__Function__CONSTRUCTOR__13
+  :: IO Function
+casadi__Function__CONSTRUCTOR__13  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__CONSTRUCTOR__13 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+function__13 :: IO Function
+function__13 = casadi__Function__CONSTRUCTOR__13
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__addMonitor" c_casadi__Function__addMonitor
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
+
+casadi__Function__addMonitor
+  :: Function -> String -> IO ()
+casadi__Function__addMonitor x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__addMonitor errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_addMonitor :: FunctionClass a => a -> String -> IO ()
+function_addMonitor x = casadi__Function__addMonitor (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__0" c_casadi__Function__call__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (Ptr (StdMap StdString (Ptr MX'))) -> IO ()
+
+casadi__Function__call__0
+  :: Function -> M.Map String MX -> IO (M.Map String MX)
+casadi__Function__call__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__0 errStrPtrP x0' x1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__0/c_casadi__Function__call__0" else wrapReturn o2''
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__0 :: FunctionClass a => a -> M.Map String MX -> IO (M.Map String MX)
+function_call__0 x = casadi__Function__call__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__1" c_casadi__Function__call__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (Ptr (StdMap StdString (Ptr MX'))) -> CInt -> IO ()
+
+casadi__Function__call__1
+  :: Function -> M.Map String MX -> Bool -> IO (M.Map String MX)
+casadi__Function__call__1 x0 x1 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__1 errStrPtrP x0' x1' o2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__1/c_casadi__Function__call__1" else wrapReturn o2''
+  marshalFree x3 x3'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__1 :: FunctionClass a => a -> M.Map String MX -> Bool -> IO (M.Map String MX)
+function_call__1 x = casadi__Function__call__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__2" c_casadi__Function__call__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (Ptr (StdMap StdString (Ptr MX'))) -> CInt -> CInt -> IO ()
+
+casadi__Function__call__2
+  :: Function -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX)
+casadi__Function__call__2 x0 x1 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__2 errStrPtrP x0' x1' o2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__2/c_casadi__Function__call__2" else wrapReturn o2''
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__2 :: FunctionClass a => a -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX)
+function_call__2 x = casadi__Function__call__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__3" c_casadi__Function__call__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (Ptr (StdMap StdString (Ptr SX'))) -> IO ()
+
+casadi__Function__call__3
+  :: Function -> M.Map String SX -> IO (M.Map String SX)
+casadi__Function__call__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__3 errStrPtrP x0' x1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__3/c_casadi__Function__call__3" else wrapReturn o2''
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__3 :: FunctionClass a => a -> M.Map String SX -> IO (M.Map String SX)
+function_call__3 x = casadi__Function__call__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__4" c_casadi__Function__call__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (Ptr (StdMap StdString (Ptr SX'))) -> CInt -> IO ()
+
+casadi__Function__call__4
+  :: Function -> M.Map String SX -> Bool -> IO (M.Map String SX)
+casadi__Function__call__4 x0 x1 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__4 errStrPtrP x0' x1' o2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__4/c_casadi__Function__call__4" else wrapReturn o2''
+  marshalFree x3 x3'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__4 :: FunctionClass a => a -> M.Map String SX -> Bool -> IO (M.Map String SX)
+function_call__4 x = casadi__Function__call__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__5" c_casadi__Function__call__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (Ptr (StdMap StdString (Ptr SX'))) -> CInt -> CInt -> IO ()
+
+casadi__Function__call__5
+  :: Function -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX)
+casadi__Function__call__5 x0 x1 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__5 errStrPtrP x0' x1' o2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__5/c_casadi__Function__call__5" else wrapReturn o2''
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__5 :: FunctionClass a => a -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX)
+function_call__5 x = casadi__Function__call__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__6" c_casadi__Function__call__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DM')) -> Ptr (Ptr (StdMap StdString (Ptr DM'))) -> IO ()
+
+casadi__Function__call__6
+  :: Function -> M.Map String DM -> IO (M.Map String DM)
+casadi__Function__call__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__6 errStrPtrP x0' x1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__6/c_casadi__Function__call__6" else wrapReturn o2''
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__6 :: FunctionClass a => a -> M.Map String DM -> IO (M.Map String DM)
+function_call__6 x = casadi__Function__call__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__7" c_casadi__Function__call__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DM')) -> Ptr (Ptr (StdMap StdString (Ptr DM'))) -> CInt -> IO ()
+
+casadi__Function__call__7
+  :: Function -> M.Map String DM -> Bool -> IO (M.Map String DM)
+casadi__Function__call__7 x0 x1 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__7 errStrPtrP x0' x1' o2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__7/c_casadi__Function__call__7" else wrapReturn o2''
+  marshalFree x3 x3'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__7 :: FunctionClass a => a -> M.Map String DM -> Bool -> IO (M.Map String DM)
+function_call__7 x = casadi__Function__call__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__8" c_casadi__Function__call__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DM')) -> Ptr (Ptr (StdMap StdString (Ptr DM'))) -> CInt -> CInt -> IO ()
+
+casadi__Function__call__8
+  :: Function -> M.Map String DM -> Bool -> Bool -> IO (M.Map String DM)
+casadi__Function__call__8 x0 x1 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__8 errStrPtrP x0' x1' o2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__8/c_casadi__Function__call__8" else wrapReturn o2''
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__8 :: FunctionClass a => a -> M.Map String DM -> Bool -> Bool -> IO (M.Map String DM)
+function_call__8 x = casadi__Function__call__8 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__9" c_casadi__Function__call__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (Ptr (StdVec (Ptr MX'))) -> IO ()
+
+casadi__Function__call__9
+  :: Function -> Vector MX -> IO (Vector MX)
+casadi__Function__call__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__9 errStrPtrP x0' x1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__9/c_casadi__Function__call__9" else wrapReturn o2''
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__9 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
+function_call__9 x = casadi__Function__call__9 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__10" c_casadi__Function__call__10
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (Ptr (StdVec (Ptr MX'))) -> CInt -> IO ()
+
+casadi__Function__call__10
+  :: Function -> Vector MX -> Bool -> IO (Vector MX)
+casadi__Function__call__10 x0 x1 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__10 errStrPtrP x0' x1' o2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__10/c_casadi__Function__call__10" else wrapReturn o2''
+  marshalFree x3 x3'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__10 :: FunctionClass a => a -> Vector MX -> Bool -> IO (Vector MX)
+function_call__10 x = casadi__Function__call__10 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__11" c_casadi__Function__call__11
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (Ptr (StdVec (Ptr MX'))) -> CInt -> CInt -> IO ()
+
+casadi__Function__call__11
+  :: Function -> Vector MX -> Bool -> Bool -> IO (Vector MX)
+casadi__Function__call__11 x0 x1 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__11 errStrPtrP x0' x1' o2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__11/c_casadi__Function__call__11" else wrapReturn o2''
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__11 :: FunctionClass a => a -> Vector MX -> Bool -> Bool -> IO (Vector MX)
+function_call__11 x = casadi__Function__call__11 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__12" c_casadi__Function__call__12
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (Ptr (StdVec (Ptr SX'))) -> IO ()
+
+casadi__Function__call__12
+  :: Function -> Vector SX -> IO (Vector SX)
+casadi__Function__call__12 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__12 errStrPtrP x0' x1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__12/c_casadi__Function__call__12" else wrapReturn o2''
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__12 :: FunctionClass a => a -> Vector SX -> IO (Vector SX)
+function_call__12 x = casadi__Function__call__12 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__13" c_casadi__Function__call__13
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (Ptr (StdVec (Ptr SX'))) -> CInt -> IO ()
+
+casadi__Function__call__13
+  :: Function -> Vector SX -> Bool -> IO (Vector SX)
+casadi__Function__call__13 x0 x1 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__13 errStrPtrP x0' x1' o2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__13/c_casadi__Function__call__13" else wrapReturn o2''
+  marshalFree x3 x3'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__13 :: FunctionClass a => a -> Vector SX -> Bool -> IO (Vector SX)
+function_call__13 x = casadi__Function__call__13 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__14" c_casadi__Function__call__14
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (Ptr (StdVec (Ptr SX'))) -> CInt -> CInt -> IO ()
+
+casadi__Function__call__14
+  :: Function -> Vector SX -> Bool -> Bool -> IO (Vector SX)
+casadi__Function__call__14 x0 x1 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__14 errStrPtrP x0' x1' o2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__14/c_casadi__Function__call__14" else wrapReturn o2''
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__14 :: FunctionClass a => a -> Vector SX -> Bool -> Bool -> IO (Vector SX)
+function_call__14 x = casadi__Function__call__14 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__15" c_casadi__Function__call__15
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (Ptr (StdVec (Ptr DM'))) -> IO ()
+
+casadi__Function__call__15
+  :: Function -> Vector DM -> IO (Vector DM)
+casadi__Function__call__15 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__15 errStrPtrP x0' x1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__15/c_casadi__Function__call__15" else wrapReturn o2''
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__15 :: FunctionClass a => a -> Vector DM -> IO (Vector DM)
+function_call__15 x = casadi__Function__call__15 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__16" c_casadi__Function__call__16
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (Ptr (StdVec (Ptr DM'))) -> CInt -> IO ()
+
+casadi__Function__call__16
+  :: Function -> Vector DM -> Bool -> IO (Vector DM)
+casadi__Function__call__16 x0 x1 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__16 errStrPtrP x0' x1' o2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__16/c_casadi__Function__call__16" else wrapReturn o2''
+  marshalFree x3 x3'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__16 :: FunctionClass a => a -> Vector DM -> Bool -> IO (Vector DM)
+function_call__16 x = casadi__Function__call__16 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__call__17" c_casadi__Function__call__17
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (Ptr (StdVec (Ptr DM'))) -> CInt -> CInt -> IO ()
+
+casadi__Function__call__17
+  :: Function -> Vector DM -> Bool -> Bool -> IO (Vector DM)
+casadi__Function__call__17 x0 x1 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__call__17 errStrPtrP x0' x1' o2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__call__17/c_casadi__Function__call__17" else wrapReturn o2''
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o2''')
+
+
+
+-- classy wrapper
+function_call__17 :: FunctionClass a => a -> Vector DM -> Bool -> Bool -> IO (Vector DM)
+function_call__17 x = casadi__Function__call__17 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__checkInputs" c_casadi__Function__checkInputs
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
+
+casadi__Function__checkInputs
+  :: Function -> IO ()
+casadi__Function__checkInputs x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__checkInputs errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+function_checkInputs :: FunctionClass a => a -> IO ()
+function_checkInputs x = casadi__Function__checkInputs (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__check_name" c_casadi__Function__check_name
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
+
+casadi__Function__check_name
+  :: String -> IO Bool
+casadi__Function__check_name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__check_name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_check_name :: String -> IO Bool
+function_check_name = casadi__Function__check_name
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__checkout" c_casadi__Function__checkout
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__checkout
+  :: Function -> IO Int
+casadi__Function__checkout x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__checkout errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_checkout :: FunctionClass a => a -> IO Int
+function_checkout x = casadi__Function__checkout (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__conditional__0" c_casadi__Function__conditional__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Function')) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__conditional__0
+  :: String -> Vector Function -> Function -> IO Function
+casadi__Function__conditional__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__conditional__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_conditional__0 :: String -> Vector Function -> Function -> IO Function
+function_conditional__0 = casadi__Function__conditional__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__conditional__1" c_casadi__Function__conditional__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Function')) -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__conditional__1
+  :: String -> Vector Function -> Function -> M.Map String GenericType -> IO Function
+casadi__Function__conditional__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__conditional__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_conditional__1 :: String -> Vector Function -> Function -> M.Map String GenericType -> IO Function
+function_conditional__1 = casadi__Function__conditional__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__default_in" c_casadi__Function__default_in
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CDouble
+
+casadi__Function__default_in
+  :: Function -> Int -> IO Double
+casadi__Function__default_in x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__default_in errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_default_in :: FunctionClass a => a -> Int -> IO Double
+function_default_in x = casadi__Function__default_in (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__0" c_casadi__Function__derivative__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__derivative__0
+  :: Function -> Int -> Int -> IO Function
+casadi__Function__derivative__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_derivative__0 :: FunctionClass a => a -> Int -> Int -> IO Function
+function_derivative__0 x = casadi__Function__derivative__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__1" c_casadi__Function__derivative__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (Ptr (StdVec (Ptr MX'))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> IO ()
+
+casadi__Function__derivative__1
+  :: Function -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO (Vector MX, Vector (Vector MX), Vector (Vector MX))
+casadi__Function__derivative__1 x0 x1 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__1 errStrPtrP x0' x1' o2' x3' o4' x5' o6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__1/c_casadi__Function__derivative__1" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__1/c_casadi__Function__derivative__1" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__1/c_casadi__Function__derivative__1" else wrapReturn o6''
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__1 :: FunctionClass a => a -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO (Vector MX, Vector (Vector MX), Vector (Vector MX))
+function_derivative__1 x = casadi__Function__derivative__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__2" c_casadi__Function__derivative__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (Ptr (StdVec (Ptr MX'))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> CInt -> IO ()
+
+casadi__Function__derivative__2
+  :: Function -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO (Vector MX, Vector (Vector MX), Vector (Vector MX))
+casadi__Function__derivative__2 x0 x1 x3 x5 x7 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+  x7' <- marshal x7
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__2 errStrPtrP x0' x1' o2' x3' o4' x5' o6' x7'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__2/c_casadi__Function__derivative__2" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__2/c_casadi__Function__derivative__2" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__2/c_casadi__Function__derivative__2" else wrapReturn o6''
+  marshalFree x7 x7'
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__2 :: FunctionClass a => a -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO (Vector MX, Vector (Vector MX), Vector (Vector MX))
+function_derivative__2 x = casadi__Function__derivative__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__3" c_casadi__Function__derivative__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (Ptr (StdVec (Ptr MX'))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__derivative__3
+  :: Function -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO (Vector MX, Vector (Vector MX), Vector (Vector MX))
+casadi__Function__derivative__3 x0 x1 x3 x5 x7 x8 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+  x7' <- marshal x7
+  x8' <- marshal x8
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__3 errStrPtrP x0' x1' o2' x3' o4' x5' o6' x7' x8'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__3/c_casadi__Function__derivative__3" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__3/c_casadi__Function__derivative__3" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__3/c_casadi__Function__derivative__3" else wrapReturn o6''
+  marshalFree x7 x7'
+  marshalFree x8 x8'
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__3 :: FunctionClass a => a -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO (Vector MX, Vector (Vector MX), Vector (Vector MX))
+function_derivative__3 x = casadi__Function__derivative__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__4" c_casadi__Function__derivative__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (Ptr (StdVec (Ptr SX'))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> IO ()
+
+casadi__Function__derivative__4
+  :: Function -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO (Vector SX, Vector (Vector SX), Vector (Vector SX))
+casadi__Function__derivative__4 x0 x1 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__4 errStrPtrP x0' x1' o2' x3' o4' x5' o6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__4/c_casadi__Function__derivative__4" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__4/c_casadi__Function__derivative__4" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__4/c_casadi__Function__derivative__4" else wrapReturn o6''
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__4 :: FunctionClass a => a -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO (Vector SX, Vector (Vector SX), Vector (Vector SX))
+function_derivative__4 x = casadi__Function__derivative__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__5" c_casadi__Function__derivative__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (Ptr (StdVec (Ptr SX'))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> CInt -> IO ()
+
+casadi__Function__derivative__5
+  :: Function -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO (Vector SX, Vector (Vector SX), Vector (Vector SX))
+casadi__Function__derivative__5 x0 x1 x3 x5 x7 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+  x7' <- marshal x7
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__5 errStrPtrP x0' x1' o2' x3' o4' x5' o6' x7'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__5/c_casadi__Function__derivative__5" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__5/c_casadi__Function__derivative__5" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__5/c_casadi__Function__derivative__5" else wrapReturn o6''
+  marshalFree x7 x7'
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__5 :: FunctionClass a => a -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO (Vector SX, Vector (Vector SX), Vector (Vector SX))
+function_derivative__5 x = casadi__Function__derivative__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__6" c_casadi__Function__derivative__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (Ptr (StdVec (Ptr SX'))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__derivative__6
+  :: Function -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO (Vector SX, Vector (Vector SX), Vector (Vector SX))
+casadi__Function__derivative__6 x0 x1 x3 x5 x7 x8 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+  x7' <- marshal x7
+  x8' <- marshal x8
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__6 errStrPtrP x0' x1' o2' x3' o4' x5' o6' x7' x8'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__6/c_casadi__Function__derivative__6" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__6/c_casadi__Function__derivative__6" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__6/c_casadi__Function__derivative__6" else wrapReturn o6''
+  marshalFree x7 x7'
+  marshalFree x8 x8'
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__6 :: FunctionClass a => a -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO (Vector SX, Vector (Vector SX), Vector (Vector SX))
+function_derivative__6 x = casadi__Function__derivative__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__7" c_casadi__Function__derivative__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (Ptr (StdVec (Ptr DM'))) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> IO ()
+
+casadi__Function__derivative__7
+  :: Function -> Vector DM -> Vector (Vector DM) -> Vector (Vector DM) -> IO (Vector DM, Vector (Vector DM), Vector (Vector DM))
+casadi__Function__derivative__7 x0 x1 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__7 errStrPtrP x0' x1' o2' x3' o4' x5' o6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__7/c_casadi__Function__derivative__7" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__7/c_casadi__Function__derivative__7" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__7/c_casadi__Function__derivative__7" else wrapReturn o6''
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__7 :: FunctionClass a => a -> Vector DM -> Vector (Vector DM) -> Vector (Vector DM) -> IO (Vector DM, Vector (Vector DM), Vector (Vector DM))
+function_derivative__7 x = casadi__Function__derivative__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__8" c_casadi__Function__derivative__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (Ptr (StdVec (Ptr DM'))) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> CInt -> IO ()
+
+casadi__Function__derivative__8
+  :: Function -> Vector DM -> Vector (Vector DM) -> Vector (Vector DM) -> Bool -> IO (Vector DM, Vector (Vector DM), Vector (Vector DM))
+casadi__Function__derivative__8 x0 x1 x3 x5 x7 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+  x7' <- marshal x7
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__8 errStrPtrP x0' x1' o2' x3' o4' x5' o6' x7'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__8/c_casadi__Function__derivative__8" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__8/c_casadi__Function__derivative__8" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__8/c_casadi__Function__derivative__8" else wrapReturn o6''
+  marshalFree x7 x7'
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__8 :: FunctionClass a => a -> Vector DM -> Vector (Vector DM) -> Vector (Vector DM) -> Bool -> IO (Vector DM, Vector (Vector DM), Vector (Vector DM))
+function_derivative__8 x = casadi__Function__derivative__8 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__derivative__9" c_casadi__Function__derivative__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (Ptr (StdVec (Ptr DM'))) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__derivative__9
+  :: Function -> Vector DM -> Vector (Vector DM) -> Vector (Vector DM) -> Bool -> Bool -> IO (Vector DM, Vector (Vector DM), Vector (Vector DM))
+casadi__Function__derivative__9 x0 x1 x3 x5 x7 x8 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  o2' <- new nullPtr
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  o6' <- new nullPtr
+  x7' <- marshal x7
+  x8' <- marshal x8
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__derivative__9 errStrPtrP x0' x1' o2' x3' o4' x5' o6' x7' x8'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__derivative__9/c_casadi__Function__derivative__9" else wrapReturn o2''
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__derivative__9/c_casadi__Function__derivative__9" else wrapReturn o4''
+  marshalFree x5 x5'
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Function__derivative__9/c_casadi__Function__derivative__9" else wrapReturn o6''
+  marshalFree x7 x7'
+  marshalFree x8 x8'
+
+  return (o2''', o4''', o6''')
+
+
+
+-- classy wrapper
+function_derivative__9 :: FunctionClass a => a -> Vector DM -> Vector (Vector DM) -> Vector (Vector DM) -> Bool -> Bool -> IO (Vector DM, Vector (Vector DM), Vector (Vector DM))
+function_derivative__9 x = casadi__Function__derivative__9 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__expand__0" c_casadi__Function__expand__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__expand__0
+  :: Function -> String -> IO Function
+casadi__Function__expand__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__expand__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_expand__0 :: FunctionClass a => a -> String -> IO Function
+function_expand__0 x = casadi__Function__expand__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__expand__1" c_casadi__Function__expand__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__expand__1
+  :: Function -> String -> M.Map String GenericType -> IO Function
+casadi__Function__expand__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__expand__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_expand__1 :: FunctionClass a => a -> String -> M.Map String GenericType -> IO Function
+function_expand__1 x = casadi__Function__expand__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__expand__2" c_casadi__Function__expand__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__expand__2
+  :: Function -> IO Function
+casadi__Function__expand__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__expand__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_expand__2 :: FunctionClass a => a -> IO Function
+function_expand__2 x = casadi__Function__expand__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__fix_name" c_casadi__Function__fix_name
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
+casadi__Function__fix_name
+  :: String -> IO String
+casadi__Function__fix_name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__fix_name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_fix_name :: String -> IO String
+function_fix_name = casadi__Function__fix_name
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__0" c_casadi__Function__forward__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+casadi__Function__forward__0
+  :: Function -> Int -> IO Function
+casadi__Function__forward__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_forward__0 :: FunctionClass a => a -> Int -> IO Function
+function_forward__0 x = casadi__Function__forward__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__1" c_casadi__Function__forward__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> IO ()
+
+casadi__Function__forward__1
+  :: Function -> Vector DM -> Vector DM -> Vector (Vector DM) -> IO (Vector (Vector DM))
+casadi__Function__forward__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__1 errStrPtrP x0' x1' x2' x3' o4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__1/c_casadi__Function__forward__1" else wrapReturn o4''
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__1 :: FunctionClass a => a -> Vector DM -> Vector DM -> Vector (Vector DM) -> IO (Vector (Vector DM))
+function_forward__1 x = casadi__Function__forward__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__2" c_casadi__Function__forward__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> CInt -> IO ()
+
+casadi__Function__forward__2
+  :: Function -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> IO (Vector (Vector DM))
+casadi__Function__forward__2 x0 x1 x2 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__2 errStrPtrP x0' x1' x2' x3' o4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__2/c_casadi__Function__forward__2" else wrapReturn o4''
+  marshalFree x5 x5'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__2 :: FunctionClass a => a -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> IO (Vector (Vector DM))
+function_forward__2 x = casadi__Function__forward__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__3" c_casadi__Function__forward__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__forward__3
+  :: Function -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> Bool -> IO (Vector (Vector DM))
+casadi__Function__forward__3 x0 x1 x2 x3 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__3 errStrPtrP x0' x1' x2' x3' o4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__3/c_casadi__Function__forward__3" else wrapReturn o4''
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__3 :: FunctionClass a => a -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> Bool -> IO (Vector (Vector DM))
+function_forward__3 x = casadi__Function__forward__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__4" c_casadi__Function__forward__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> IO ()
+
+casadi__Function__forward__4
+  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> IO (Vector (Vector SX))
+casadi__Function__forward__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__4 errStrPtrP x0' x1' x2' x3' o4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__4/c_casadi__Function__forward__4" else wrapReturn o4''
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> IO (Vector (Vector SX))
+function_forward__4 x = casadi__Function__forward__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__5" c_casadi__Function__forward__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> CInt -> IO ()
+
+casadi__Function__forward__5
+  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> IO (Vector (Vector SX))
+casadi__Function__forward__5 x0 x1 x2 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__5 errStrPtrP x0' x1' x2' x3' o4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__5/c_casadi__Function__forward__5" else wrapReturn o4''
+  marshalFree x5 x5'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> IO (Vector (Vector SX))
+function_forward__5 x = casadi__Function__forward__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__6" c_casadi__Function__forward__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__forward__6
+  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> Bool -> IO (Vector (Vector SX))
+casadi__Function__forward__6 x0 x1 x2 x3 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__6 errStrPtrP x0' x1' x2' x3' o4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__6/c_casadi__Function__forward__6" else wrapReturn o4''
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__6 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> Bool -> IO (Vector (Vector SX))
+function_forward__6 x = casadi__Function__forward__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__7" c_casadi__Function__forward__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> IO ()
+
+casadi__Function__forward__7
+  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> IO (Vector (Vector MX))
+casadi__Function__forward__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__7 errStrPtrP x0' x1' x2' x3' o4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__7/c_casadi__Function__forward__7" else wrapReturn o4''
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> IO (Vector (Vector MX))
+function_forward__7 x = casadi__Function__forward__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__8" c_casadi__Function__forward__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> CInt -> IO ()
+
+casadi__Function__forward__8
+  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> IO (Vector (Vector MX))
+casadi__Function__forward__8 x0 x1 x2 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__8 errStrPtrP x0' x1' x2' x3' o4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__8/c_casadi__Function__forward__8" else wrapReturn o4''
+  marshalFree x5 x5'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> IO (Vector (Vector MX))
+function_forward__8 x = casadi__Function__forward__8 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__forward__9" c_casadi__Function__forward__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__forward__9
+  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> Bool -> IO (Vector (Vector MX))
+casadi__Function__forward__9 x0 x1 x2 x3 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__forward__9 errStrPtrP x0' x1' x2' x3' o4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__forward__9/c_casadi__Function__forward__9" else wrapReturn o4''
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_forward__9 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> Bool -> IO (Vector (Vector MX))
+function_forward__9 x = casadi__Function__forward__9 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__free_mx" c_casadi__Function__free_mx
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__Function__free_mx
+  :: Function -> IO (Vector MX)
+casadi__Function__free_mx x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__free_mx errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_free_mx :: FunctionClass a => a -> IO (Vector MX)
+function_free_mx x = casadi__Function__free_mx (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__free_sx" c_casadi__Function__free_sx
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SX')
+
+casadi__Function__free_sx
+  :: Function -> IO SX
+casadi__Function__free_sx x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__free_sx errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_free_sx :: FunctionClass a => a -> IO SX
+function_free_sx x = casadi__Function__free_sx (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__fullJacobian" c_casadi__Function__fullJacobian
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__fullJacobian
+  :: Function -> IO Function
+casadi__Function__fullJacobian x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__fullJacobian errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_fullJacobian :: FunctionClass a => a -> IO Function
+function_fullJacobian x = casadi__Function__fullJacobian (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generate__0" c_casadi__Function__generate__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
+
+casadi__Function__generate__0
+  :: Function -> IO ()
+casadi__Function__generate__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__generate__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+function_generate__0 :: FunctionClass a => a -> IO ()
+function_generate__0 x = casadi__Function__generate__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generate__1" c_casadi__Function__generate__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
+
+casadi__Function__generate__1
+  :: Function -> M.Map String GenericType -> IO ()
+casadi__Function__generate__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__generate__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_generate__1 :: FunctionClass a => a -> M.Map String GenericType -> IO ()
+function_generate__1 x = casadi__Function__generate__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generate__2" c_casadi__Function__generate__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
+
+casadi__Function__generate__2
+  :: Function -> String -> IO ()
+casadi__Function__generate__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__generate__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_generate__2 :: FunctionClass a => a -> String -> IO ()
+function_generate__2 x = casadi__Function__generate__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generate__3" c_casadi__Function__generate__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
+
+casadi__Function__generate__3
+  :: Function -> String -> M.Map String GenericType -> IO ()
+casadi__Function__generate__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__generate__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+function_generate__3 :: FunctionClass a => a -> String -> M.Map String GenericType -> IO ()
+function_generate__3 x = casadi__Function__generate__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generate_dependencies__0" c_casadi__Function__generate_dependencies__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
+
+casadi__Function__generate_dependencies__0
+  :: Function -> String -> IO ()
+casadi__Function__generate_dependencies__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__generate_dependencies__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_generate_dependencies__0 :: FunctionClass a => a -> String -> IO ()
+function_generate_dependencies__0 x = casadi__Function__generate_dependencies__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generate_dependencies__1" c_casadi__Function__generate_dependencies__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
+
+casadi__Function__generate_dependencies__1
+  :: Function -> String -> M.Map String GenericType -> IO ()
+casadi__Function__generate_dependencies__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__generate_dependencies__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+function_generate_dependencies__1 :: FunctionClass a => a -> String -> M.Map String GenericType -> IO ()
+function_generate_dependencies__1 x = casadi__Function__generate_dependencies__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generate_lifted" c_casadi__Function__generate_lifted
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (Ptr Function') -> Ptr (Ptr Function') -> IO ()
+
+casadi__Function__generate_lifted
+  :: Function -> IO (Function, Function)
+casadi__Function__generate_lifted x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__generate_lifted errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Function__generate_lifted/c_casadi__Function__generate_lifted" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Function__generate_lifted/c_casadi__Function__generate_lifted" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+-- classy wrapper
+function_generate_lifted :: FunctionClass a => a -> IO (Function, Function)
+function_generate_lifted x = casadi__Function__generate_lifted (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__getAlgorithmSize" c_casadi__Function__getAlgorithmSize
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__getAlgorithmSize
+  :: Function -> IO Int
+casadi__Function__getAlgorithmSize x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__getAlgorithmSize errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_getAlgorithmSize :: FunctionClass a => a -> IO Int
+function_getAlgorithmSize x = casadi__Function__getAlgorithmSize (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__getAtomicInput" c_casadi__Function__getAtomicInput
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr (StdPair CInt CInt))
+
+casadi__Function__getAtomicInput
+  :: Function -> Int -> IO (Int, Int)
+casadi__Function__getAtomicInput x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__getAtomicInput errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_getAtomicInput :: FunctionClass a => a -> Int -> IO (Int, Int)
+function_getAtomicInput x = casadi__Function__getAtomicInput (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__getAtomicInputReal" c_casadi__Function__getAtomicInputReal
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CDouble
+
+casadi__Function__getAtomicInputReal
+  :: Function -> Int -> IO Double
+casadi__Function__getAtomicInputReal x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__getAtomicInputReal errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_getAtomicInputReal :: FunctionClass a => a -> Int -> IO Double
+function_getAtomicInputReal x = casadi__Function__getAtomicInputReal (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__getAtomicOperation" c_casadi__Function__getAtomicOperation
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__getAtomicOperation
+  :: Function -> Int -> IO Int
+casadi__Function__getAtomicOperation x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__getAtomicOperation errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_getAtomicOperation :: FunctionClass a => a -> Int -> IO Int
+function_getAtomicOperation x = casadi__Function__getAtomicOperation (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__getAtomicOutput" c_casadi__Function__getAtomicOutput
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__getAtomicOutput
+  :: Function -> Int -> IO Int
+casadi__Function__getAtomicOutput x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__getAtomicOutput errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_getAtomicOutput :: FunctionClass a => a -> Int -> IO Int
+function_getAtomicOutput x = casadi__Function__getAtomicOutput (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__getWorkSize" c_casadi__Function__getWorkSize
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__getWorkSize
+  :: Function -> IO Int
+casadi__Function__getWorkSize x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__getWorkSize errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_getWorkSize :: FunctionClass a => a -> IO Int
+function_getWorkSize x = casadi__Function__getWorkSize (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__gradient__0" c_casadi__Function__gradient__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__gradient__0
+  :: Function -> String -> String -> IO Function
+casadi__Function__gradient__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__gradient__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_gradient__0 :: FunctionClass a => a -> String -> String -> IO Function
+function_gradient__0 x = casadi__Function__gradient__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__gradient__1" c_casadi__Function__gradient__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__gradient__1
+  :: Function -> Int -> String -> IO Function
+casadi__Function__gradient__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__gradient__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_gradient__1 :: FunctionClass a => a -> Int -> String -> IO Function
+function_gradient__1 x = casadi__Function__gradient__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__gradient__2" c_casadi__Function__gradient__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__gradient__2
+  :: Function -> String -> IO Function
+casadi__Function__gradient__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__gradient__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_gradient__2 :: FunctionClass a => a -> String -> IO Function
+function_gradient__2 x = casadi__Function__gradient__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__gradient__3" c_casadi__Function__gradient__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__gradient__3
+  :: Function -> String -> Int -> IO Function
+casadi__Function__gradient__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__gradient__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_gradient__3 :: FunctionClass a => a -> String -> Int -> IO Function
+function_gradient__3 x = casadi__Function__gradient__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__gradient__4" c_casadi__Function__gradient__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__gradient__4
+  :: Function -> IO Function
+casadi__Function__gradient__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__gradient__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_gradient__4 :: FunctionClass a => a -> IO Function
+function_gradient__4 x = casadi__Function__gradient__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__gradient__5" c_casadi__Function__gradient__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+casadi__Function__gradient__5
+  :: Function -> Int -> IO Function
+casadi__Function__gradient__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__gradient__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_gradient__5 :: FunctionClass a => a -> Int -> IO Function
+function_gradient__5 x = casadi__Function__gradient__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__gradient__6" c_casadi__Function__gradient__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__gradient__6
+  :: Function -> Int -> Int -> IO Function
+casadi__Function__gradient__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__gradient__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_gradient__6 :: FunctionClass a => a -> Int -> Int -> IO Function
+function_gradient__6 x = casadi__Function__gradient__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__has_free" c_casadi__Function__has_free
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__has_free
+  :: Function -> IO Bool
+casadi__Function__has_free x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__has_free errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_has_free :: FunctionClass a => a -> IO Bool
+function_has_free x = casadi__Function__has_free (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__hessian__0" c_casadi__Function__hessian__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__hessian__0
+  :: Function -> String -> String -> IO Function
+casadi__Function__hessian__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__hessian__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_hessian__0 :: FunctionClass a => a -> String -> String -> IO Function
+function_hessian__0 x = casadi__Function__hessian__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__hessian__1" c_casadi__Function__hessian__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__hessian__1
+  :: Function -> Int -> String -> IO Function
+casadi__Function__hessian__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__hessian__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_hessian__1 :: FunctionClass a => a -> Int -> String -> IO Function
+function_hessian__1 x = casadi__Function__hessian__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__hessian__2" c_casadi__Function__hessian__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__hessian__2
+  :: Function -> String -> IO Function
+casadi__Function__hessian__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__hessian__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_hessian__2 :: FunctionClass a => a -> String -> IO Function
+function_hessian__2 x = casadi__Function__hessian__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__hessian__3" c_casadi__Function__hessian__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__hessian__3
+  :: Function -> String -> Int -> IO Function
+casadi__Function__hessian__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__hessian__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_hessian__3 :: FunctionClass a => a -> String -> Int -> IO Function
+function_hessian__3 x = casadi__Function__hessian__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__hessian__4" c_casadi__Function__hessian__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__hessian__4
+  :: Function -> IO Function
+casadi__Function__hessian__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__hessian__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_hessian__4 :: FunctionClass a => a -> IO Function
+function_hessian__4 x = casadi__Function__hessian__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__hessian__5" c_casadi__Function__hessian__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+casadi__Function__hessian__5
+  :: Function -> Int -> IO Function
+casadi__Function__hessian__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__hessian__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_hessian__5 :: FunctionClass a => a -> Int -> IO Function
+function_hessian__5 x = casadi__Function__hessian__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__hessian__6" c_casadi__Function__hessian__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__hessian__6
+  :: Function -> Int -> Int -> IO Function
+casadi__Function__hessian__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__hessian__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_hessian__6 :: FunctionClass a => a -> Int -> Int -> IO Function
+function_hessian__6 x = casadi__Function__hessian__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__if_else__0" c_casadi__Function__if_else__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__if_else__0
+  :: String -> Function -> Function -> IO Function
+casadi__Function__if_else__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__if_else__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_if_else__0 :: String -> Function -> Function -> IO Function
+function_if_else__0 = casadi__Function__if_else__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__if_else__1" c_casadi__Function__if_else__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__if_else__1
+  :: String -> Function -> Function -> M.Map String GenericType -> IO Function
+casadi__Function__if_else__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__if_else__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_if_else__1 :: String -> Function -> Function -> M.Map String GenericType -> IO Function
+function_if_else__1 = casadi__Function__if_else__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__index_in" c_casadi__Function__index_in
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__index_in
+  :: Function -> String -> IO Int
+casadi__Function__index_in x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__index_in errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_index_in :: FunctionClass a => a -> String -> IO Int
+function_index_in x = casadi__Function__index_in (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__index_out" c_casadi__Function__index_out
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__index_out
+  :: Function -> String -> IO Int
+casadi__Function__index_out x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__index_out errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_index_out :: FunctionClass a => a -> String -> IO Int
+function_index_out x = casadi__Function__index_out (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__integrator_dae" c_casadi__Function__integrator_dae
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__integrator_dae
+  :: Function -> IO Function
+casadi__Function__integrator_dae x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__integrator_dae errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_integrator_dae :: FunctionClass a => a -> IO Function
+function_integrator_dae x = casadi__Function__integrator_dae (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__is_a__0" c_casadi__Function__is_a__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__is_a__0
+  :: Function -> String -> IO Bool
+casadi__Function__is_a__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__is_a__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_is_a__0 :: FunctionClass a => a -> String -> IO Bool
+function_is_a__0 x = casadi__Function__is_a__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__is_a__1" c_casadi__Function__is_a__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO CInt
+
+casadi__Function__is_a__1
+  :: Function -> String -> Bool -> IO Bool
+casadi__Function__is_a__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__is_a__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_is_a__1 :: FunctionClass a => a -> String -> Bool -> IO Bool
+function_is_a__1 x = casadi__Function__is_a__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__0" c_casadi__Function__jacobian__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__jacobian__0
+  :: Function -> String -> String -> IO Function
+casadi__Function__jacobian__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__0 :: FunctionClass a => a -> String -> String -> IO Function
+function_jacobian__0 x = casadi__Function__jacobian__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__1" c_casadi__Function__jacobian__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__1
+  :: Function -> String -> String -> Bool -> IO Function
+casadi__Function__jacobian__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Function
+function_jacobian__1 x = casadi__Function__jacobian__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__2" c_casadi__Function__jacobian__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__2
+  :: Function -> String -> String -> Bool -> Bool -> IO Function
+casadi__Function__jacobian__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Function
+function_jacobian__2 x = casadi__Function__jacobian__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__3" c_casadi__Function__jacobian__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__jacobian__3
+  :: Function -> Int -> String -> IO Function
+casadi__Function__jacobian__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__3 :: FunctionClass a => a -> Int -> String -> IO Function
+function_jacobian__3 x = casadi__Function__jacobian__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__4" c_casadi__Function__jacobian__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__4
+  :: Function -> Int -> String -> Bool -> IO Function
+casadi__Function__jacobian__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Function
+function_jacobian__4 x = casadi__Function__jacobian__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__5" c_casadi__Function__jacobian__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__5
+  :: Function -> Int -> String -> Bool -> Bool -> IO Function
+casadi__Function__jacobian__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Function
+function_jacobian__5 x = casadi__Function__jacobian__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__6" c_casadi__Function__jacobian__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__jacobian__6
+  :: Function -> String -> IO Function
+casadi__Function__jacobian__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__6 :: FunctionClass a => a -> String -> IO Function
+function_jacobian__6 x = casadi__Function__jacobian__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__7" c_casadi__Function__jacobian__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__7
+  :: Function -> String -> Int -> IO Function
+casadi__Function__jacobian__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__7 :: FunctionClass a => a -> String -> Int -> IO Function
+function_jacobian__7 x = casadi__Function__jacobian__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__8" c_casadi__Function__jacobian__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__8
+  :: Function -> String -> Int -> Bool -> IO Function
+casadi__Function__jacobian__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Function
+function_jacobian__8 x = casadi__Function__jacobian__8 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__9" c_casadi__Function__jacobian__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__9
+  :: Function -> String -> Int -> Bool -> Bool -> IO Function
+casadi__Function__jacobian__9 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__9 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Function
+function_jacobian__9 x = casadi__Function__jacobian__9 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__10" c_casadi__Function__jacobian__10
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__jacobian__10
+  :: Function -> IO Function
+casadi__Function__jacobian__10 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__10 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__10 :: FunctionClass a => a -> IO Function
+function_jacobian__10 x = casadi__Function__jacobian__10 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__11" c_casadi__Function__jacobian__11
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__11
+  :: Function -> Int -> IO Function
+casadi__Function__jacobian__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__11 :: FunctionClass a => a -> Int -> IO Function
+function_jacobian__11 x = casadi__Function__jacobian__11 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__12" c_casadi__Function__jacobian__12
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__12
+  :: Function -> Int -> Int -> IO Function
+casadi__Function__jacobian__12 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__12 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__12 :: FunctionClass a => a -> Int -> Int -> IO Function
+function_jacobian__12 x = casadi__Function__jacobian__12 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__13" c_casadi__Function__jacobian__13
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__13
+  :: Function -> Int -> Int -> Bool -> IO Function
+casadi__Function__jacobian__13 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__13 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Function
+function_jacobian__13 x = casadi__Function__jacobian__13 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__jacobian__14" c_casadi__Function__jacobian__14
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__jacobian__14
+  :: Function -> Int -> Int -> Bool -> Bool -> IO Function
+casadi__Function__jacobian__14 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__jacobian__14 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_jacobian__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Function
+function_jacobian__14 x = casadi__Function__jacobian__14 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__kernel_sum__0" c_casadi__Function__kernel_sum__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdPair CInt CInt) -> CDouble -> CInt -> IO (Ptr Function')
+
+casadi__Function__kernel_sum__0
+  :: Function -> String -> (Int, Int) -> Double -> Int -> IO Function
+casadi__Function__kernel_sum__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__kernel_sum__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_kernel_sum__0 :: FunctionClass a => a -> String -> (Int, Int) -> Double -> Int -> IO Function
+function_kernel_sum__0 x = casadi__Function__kernel_sum__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__kernel_sum__1" c_casadi__Function__kernel_sum__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdPair CInt CInt) -> CDouble -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__kernel_sum__1
+  :: Function -> String -> (Int, Int) -> Double -> Int -> M.Map String GenericType -> IO Function
+casadi__Function__kernel_sum__1 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__kernel_sum__1 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+-- classy wrapper
+function_kernel_sum__1 :: FunctionClass a => a -> String -> (Int, Int) -> Double -> Int -> M.Map String GenericType -> IO Function
+function_kernel_sum__1 x = casadi__Function__kernel_sum__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_cholesky__0" c_casadi__Function__linsol_cholesky__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr DM')
+
+casadi__Function__linsol_cholesky__0
+  :: Function -> IO DM
+casadi__Function__linsol_cholesky__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_cholesky__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_cholesky__0 :: FunctionClass a => a -> IO DM
+function_linsol_cholesky__0 x = casadi__Function__linsol_cholesky__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_cholesky__1" c_casadi__Function__linsol_cholesky__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr DM')
+
+casadi__Function__linsol_cholesky__1
+  :: Function -> Bool -> IO DM
+casadi__Function__linsol_cholesky__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_cholesky__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_cholesky__1 :: FunctionClass a => a -> Bool -> IO DM
+function_linsol_cholesky__1 x = casadi__Function__linsol_cholesky__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_cholesky__2" c_casadi__Function__linsol_cholesky__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi__Function__linsol_cholesky__2
+  :: Function -> Bool -> Int -> IO DM
+casadi__Function__linsol_cholesky__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_cholesky__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_cholesky__2 :: FunctionClass a => a -> Bool -> Int -> IO DM
+function_linsol_cholesky__2 x = casadi__Function__linsol_cholesky__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_cholesky_sparsity__0" c_casadi__Function__linsol_cholesky_sparsity__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity')
+
+casadi__Function__linsol_cholesky_sparsity__0
+  :: Function -> IO Sparsity
+casadi__Function__linsol_cholesky_sparsity__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_cholesky_sparsity__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_cholesky_sparsity__0 :: FunctionClass a => a -> IO Sparsity
+function_linsol_cholesky_sparsity__0 x = casadi__Function__linsol_cholesky_sparsity__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_cholesky_sparsity__1" c_casadi__Function__linsol_cholesky_sparsity__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__linsol_cholesky_sparsity__1
+  :: Function -> Bool -> IO Sparsity
+casadi__Function__linsol_cholesky_sparsity__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_cholesky_sparsity__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_cholesky_sparsity__1 :: FunctionClass a => a -> Bool -> IO Sparsity
+function_linsol_cholesky_sparsity__1 x = casadi__Function__linsol_cholesky_sparsity__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_cholesky_sparsity__2" c_casadi__Function__linsol_cholesky_sparsity__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__linsol_cholesky_sparsity__2
+  :: Function -> Bool -> Int -> IO Sparsity
+casadi__Function__linsol_cholesky_sparsity__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_cholesky_sparsity__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_cholesky_sparsity__2 :: FunctionClass a => a -> Bool -> Int -> IO Sparsity
+function_linsol_cholesky_sparsity__2 x = casadi__Function__linsol_cholesky_sparsity__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_solve__0" c_casadi__Function__linsol_solve__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__Function__linsol_solve__0
+  :: Function -> MX -> MX -> IO MX
+casadi__Function__linsol_solve__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_solve__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_solve__0 :: FunctionClass a => a -> MX -> MX -> IO MX
+function_linsol_solve__0 x = casadi__Function__linsol_solve__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__linsol_solve__1" c_casadi__Function__linsol_solve__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi__Function__linsol_solve__1
+  :: Function -> MX -> MX -> Bool -> IO MX
+casadi__Function__linsol_solve__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__linsol_solve__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_linsol_solve__1 :: FunctionClass a => a -> MX -> MX -> Bool -> IO MX
+function_linsol_solve__1 x = casadi__Function__linsol_solve__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__0" c_casadi__Function__map__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__map__0
+  :: Function -> String -> String -> Int -> IO Function
+casadi__Function__map__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__0 :: FunctionClass a => a -> String -> String -> Int -> IO Function
+function_map__0 x = casadi__Function__map__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__1" c_casadi__Function__map__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__map__1
+  :: Function -> String -> String -> Int -> M.Map String GenericType -> IO Function
+casadi__Function__map__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__1 :: FunctionClass a => a -> String -> String -> Int -> M.Map String GenericType -> IO Function
+function_map__1 x = casadi__Function__map__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__2" c_casadi__Function__map__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Function')
+
+casadi__Function__map__2
+  :: Function -> String -> String -> Int -> Vector Int -> Vector Int -> IO Function
+casadi__Function__map__2 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__2 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__2 :: FunctionClass a => a -> String -> String -> Int -> Vector Int -> Vector Int -> IO Function
+function_map__2 x = casadi__Function__map__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__3" c_casadi__Function__map__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__map__3
+  :: Function -> String -> String -> Int -> Vector Int -> Vector Int -> M.Map String GenericType -> IO Function
+casadi__Function__map__3 x0 x1 x2 x3 x4 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__3 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__3 :: FunctionClass a => a -> String -> String -> Int -> Vector Int -> Vector Int -> M.Map String GenericType -> IO Function
+function_map__3 x = casadi__Function__map__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__4" c_casadi__Function__map__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr (StdMap StdString (Ptr MX')))
+
+casadi__Function__map__4
+  :: Function -> M.Map String MX -> IO (M.Map String MX)
+casadi__Function__map__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__4 :: FunctionClass a => a -> M.Map String MX -> IO (M.Map String MX)
+function_map__4 x = casadi__Function__map__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__5" c_casadi__Function__map__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdMap StdString (Ptr MX')))
+
+casadi__Function__map__5
+  :: Function -> M.Map String MX -> String -> IO (M.Map String MX)
+casadi__Function__map__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__5 :: FunctionClass a => a -> M.Map String MX -> String -> IO (M.Map String MX)
+function_map__5 x = casadi__Function__map__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__6" c_casadi__Function__map__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__Function__map__6
+  :: Function -> Vector MX -> IO (Vector MX)
+casadi__Function__map__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__6 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
+function_map__6 x = casadi__Function__map__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__map__7" c_casadi__Function__map__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__Function__map__7
+  :: Function -> Vector MX -> String -> IO (Vector MX)
+casadi__Function__map__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__map__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_map__7 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX)
+function_map__7 x = casadi__Function__map__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mapaccum__0" c_casadi__Function__mapaccum__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Function')
+
+casadi__Function__mapaccum__0
+  :: Function -> String -> Int -> Vector Int -> Vector Int -> IO Function
+casadi__Function__mapaccum__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mapaccum__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mapaccum__0 :: FunctionClass a => a -> String -> Int -> Vector Int -> Vector Int -> IO Function
+function_mapaccum__0 x = casadi__Function__mapaccum__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mapaccum__1" c_casadi__Function__mapaccum__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__mapaccum__1
+  :: Function -> String -> Int -> Vector Int -> Vector Int -> M.Map String GenericType -> IO Function
+casadi__Function__mapaccum__1 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mapaccum__1 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mapaccum__1 :: FunctionClass a => a -> String -> Int -> Vector Int -> Vector Int -> M.Map String GenericType -> IO Function
+function_mapaccum__1 x = casadi__Function__mapaccum__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mapaccum__2" c_casadi__Function__mapaccum__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__mapaccum__2
+  :: Function -> String -> Int -> IO Function
+casadi__Function__mapaccum__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mapaccum__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mapaccum__2 :: FunctionClass a => a -> String -> Int -> IO Function
+function_mapaccum__2 x = casadi__Function__mapaccum__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mapaccum__3" c_casadi__Function__mapaccum__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__mapaccum__3
+  :: Function -> String -> Int -> M.Map String GenericType -> IO Function
+casadi__Function__mapaccum__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mapaccum__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mapaccum__3 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function
+function_mapaccum__3 x = casadi__Function__mapaccum__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mapsum__0" c_casadi__Function__mapsum__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__Function__mapsum__0
+  :: Function -> Vector MX -> IO (Vector MX)
+casadi__Function__mapsum__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mapsum__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mapsum__0 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
+function_mapsum__0 x = casadi__Function__mapsum__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mapsum__1" c_casadi__Function__mapsum__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__Function__mapsum__1
+  :: Function -> Vector MX -> String -> IO (Vector MX)
+casadi__Function__mapsum__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mapsum__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mapsum__1 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX)
+function_mapsum__1 x = casadi__Function__mapsum__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mx_in__0" c_casadi__Function__mx_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__Function__mx_in__0
+  :: Function -> IO (Vector MX)
+casadi__Function__mx_in__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mx_in__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mx_in__0 :: FunctionClass a => a -> IO (Vector MX)
+function_mx_in__0 x = casadi__Function__mx_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mx_in__1" c_casadi__Function__mx_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__Function__mx_in__1
+  :: Function -> String -> IO MX
+casadi__Function__mx_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mx_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mx_in__1 :: FunctionClass a => a -> String -> IO MX
+function_mx_in__1 x = casadi__Function__mx_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mx_in__2" c_casadi__Function__mx_in__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MX')
+
+casadi__Function__mx_in__2
+  :: Function -> Int -> IO MX
+casadi__Function__mx_in__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mx_in__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mx_in__2 :: FunctionClass a => a -> Int -> IO MX
+function_mx_in__2 x = casadi__Function__mx_in__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mx_out__0" c_casadi__Function__mx_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__Function__mx_out__0
+  :: Function -> IO (Vector MX)
+casadi__Function__mx_out__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mx_out__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mx_out__0 :: FunctionClass a => a -> IO (Vector MX)
+function_mx_out__0 x = casadi__Function__mx_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mx_out__1" c_casadi__Function__mx_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__Function__mx_out__1
+  :: Function -> String -> IO MX
+casadi__Function__mx_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mx_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mx_out__1 :: FunctionClass a => a -> String -> IO MX
+function_mx_out__1 x = casadi__Function__mx_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__mx_out__2" c_casadi__Function__mx_out__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MX')
+
+casadi__Function__mx_out__2
+  :: Function -> Int -> IO MX
+casadi__Function__mx_out__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__mx_out__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_mx_out__2 :: FunctionClass a => a -> Int -> IO MX
+function_mx_out__2 x = casadi__Function__mx_out__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__n_in" c_casadi__Function__n_in
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__n_in
+  :: Function -> IO Int
+casadi__Function__n_in x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__n_in errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_n_in :: FunctionClass a => a -> IO Int
+function_n_in x = casadi__Function__n_in (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__n_nodes" c_casadi__Function__n_nodes
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__n_nodes
+  :: Function -> IO Int
+casadi__Function__n_nodes x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__n_nodes errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_n_nodes :: FunctionClass a => a -> IO Int
+function_n_nodes x = casadi__Function__n_nodes (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__n_out" c_casadi__Function__n_out
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__n_out
+  :: Function -> IO Int
+casadi__Function__n_out x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__n_out errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_n_out :: FunctionClass a => a -> IO Int
+function_n_out x = casadi__Function__n_out (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__name" c_casadi__Function__name
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString)
+
+casadi__Function__name
+  :: Function -> IO String
+casadi__Function__name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_name :: FunctionClass a => a -> IO String
+function_name x = casadi__Function__name (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__name_in__0" c_casadi__Function__name_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString)
+
+casadi__Function__name_in__0
+  :: Function -> Int -> IO String
+casadi__Function__name_in__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__name_in__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_name_in__0 :: FunctionClass a => a -> Int -> IO String
+function_name_in__0 x = casadi__Function__name_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__name_in__1" c_casadi__Function__name_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString)))
+
+casadi__Function__name_in__1
+  :: Function -> IO (Vector String)
+casadi__Function__name_in__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__name_in__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_name_in__1 :: FunctionClass a => a -> IO (Vector String)
+function_name_in__1 x = casadi__Function__name_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__name_out__0" c_casadi__Function__name_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString)
+
+casadi__Function__name_out__0
+  :: Function -> Int -> IO String
+casadi__Function__name_out__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__name_out__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_name_out__0 :: FunctionClass a => a -> Int -> IO String
+function_name_out__0 x = casadi__Function__name_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__name_out__1" c_casadi__Function__name_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString)))
+
+casadi__Function__name_out__1
+  :: Function -> IO (Vector String)
+casadi__Function__name_out__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__name_out__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_name_out__1 :: FunctionClass a => a -> IO (Vector String)
+function_name_out__1 x = casadi__Function__name_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__nnz_in__0" c_casadi__Function__nnz_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__nnz_in__0
+  :: Function -> String -> IO Int
+casadi__Function__nnz_in__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__nnz_in__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_nnz_in__0 :: FunctionClass a => a -> String -> IO Int
+function_nnz_in__0 x = casadi__Function__nnz_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__nnz_in__1" c_casadi__Function__nnz_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__nnz_in__1
+  :: Function -> Int -> IO Int
+casadi__Function__nnz_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__nnz_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_nnz_in__1 :: FunctionClass a => a -> Int -> IO Int
+function_nnz_in__1 x = casadi__Function__nnz_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__nnz_in__2" c_casadi__Function__nnz_in__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__nnz_in__2
+  :: Function -> IO Int
+casadi__Function__nnz_in__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__nnz_in__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_nnz_in__2 :: FunctionClass a => a -> IO Int
+function_nnz_in__2 x = casadi__Function__nnz_in__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__nnz_out__0" c_casadi__Function__nnz_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__nnz_out__0
+  :: Function -> String -> IO Int
+casadi__Function__nnz_out__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__nnz_out__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_nnz_out__0 :: FunctionClass a => a -> String -> IO Int
+function_nnz_out__0 x = casadi__Function__nnz_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__nnz_out__1" c_casadi__Function__nnz_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__nnz_out__1
+  :: Function -> Int -> IO Int
+casadi__Function__nnz_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__nnz_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_nnz_out__1 :: FunctionClass a => a -> Int -> IO Int
+function_nnz_out__1 x = casadi__Function__nnz_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__nnz_out__2" c_casadi__Function__nnz_out__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__nnz_out__2
+  :: Function -> IO Int
+casadi__Function__nnz_out__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__nnz_out__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_nnz_out__2 :: FunctionClass a => a -> IO Int
+function_nnz_out__2 x = casadi__Function__nnz_out__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__numel_in__0" c_casadi__Function__numel_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__numel_in__0
+  :: Function -> String -> IO Int
+casadi__Function__numel_in__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__numel_in__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_numel_in__0 :: FunctionClass a => a -> String -> IO Int
+function_numel_in__0 x = casadi__Function__numel_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__numel_in__1" c_casadi__Function__numel_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__numel_in__1
+  :: Function -> Int -> IO Int
+casadi__Function__numel_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__numel_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_numel_in__1 :: FunctionClass a => a -> Int -> IO Int
+function_numel_in__1 x = casadi__Function__numel_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__numel_in__2" c_casadi__Function__numel_in__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__numel_in__2
+  :: Function -> IO Int
+casadi__Function__numel_in__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__numel_in__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_numel_in__2 :: FunctionClass a => a -> IO Int
+function_numel_in__2 x = casadi__Function__numel_in__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__numel_out__0" c_casadi__Function__numel_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__numel_out__0
+  :: Function -> String -> IO Int
+casadi__Function__numel_out__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__numel_out__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_numel_out__0 :: FunctionClass a => a -> String -> IO Int
+function_numel_out__0 x = casadi__Function__numel_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__numel_out__1" c_casadi__Function__numel_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__numel_out__1
+  :: Function -> Int -> IO Int
+casadi__Function__numel_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__numel_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_numel_out__1 :: FunctionClass a => a -> Int -> IO Int
+function_numel_out__1 x = casadi__Function__numel_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__numel_out__2" c_casadi__Function__numel_out__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
+
+casadi__Function__numel_out__2
+  :: Function -> IO Int
+casadi__Function__numel_out__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__numel_out__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_numel_out__2 :: FunctionClass a => a -> IO Int
+function_numel_out__2 x = casadi__Function__numel_out__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__printDimensions" c_casadi__Function__printDimensions
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
+
+casadi__Function__printDimensions
+  :: Function -> IO ()
+casadi__Function__printDimensions x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__printDimensions errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+function_printDimensions :: FunctionClass a => a -> IO ()
+function_printDimensions x = casadi__Function__printDimensions (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__printOption" c_casadi__Function__printOption
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
+
+casadi__Function__printOption
+  :: Function -> String -> IO ()
+casadi__Function__printOption x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__printOption errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_printOption :: FunctionClass a => a -> String -> IO ()
+function_printOption x = casadi__Function__printOption (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__printOptions" c_casadi__Function__printOptions
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
+
+casadi__Function__printOptions
+  :: Function -> IO ()
+casadi__Function__printOptions x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__printOptions errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+function_printOptions :: FunctionClass a => a -> IO ()
+function_printOptions x = casadi__Function__printOptions (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__qpsol_debug" c_casadi__Function__qpsol_debug
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
+
+casadi__Function__qpsol_debug
+  :: Function -> String -> IO ()
+casadi__Function__qpsol_debug x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__qpsol_debug errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_qpsol_debug :: FunctionClass a => a -> String -> IO ()
+function_qpsol_debug x = casadi__Function__qpsol_debug (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__release" c_casadi__Function__release
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO ()
+
+casadi__Function__release
+  :: Function -> Int -> IO ()
+casadi__Function__release x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__release errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_release :: FunctionClass a => a -> Int -> IO ()
+function_release x = casadi__Function__release (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__removeMonitor" c_casadi__Function__removeMonitor
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
+
+casadi__Function__removeMonitor
+  :: Function -> String -> IO ()
+casadi__Function__removeMonitor x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__removeMonitor errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_removeMonitor :: FunctionClass a => a -> String -> IO ()
+function_removeMonitor x = casadi__Function__removeMonitor (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__0" c_casadi__Function__reverse__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+casadi__Function__reverse__0
+  :: Function -> Int -> IO Function
+casadi__Function__reverse__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_reverse__0 :: FunctionClass a => a -> Int -> IO Function
+function_reverse__0 x = casadi__Function__reverse__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__1" c_casadi__Function__reverse__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> IO ()
+
+casadi__Function__reverse__1
+  :: Function -> Vector DM -> Vector DM -> Vector (Vector DM) -> IO (Vector (Vector DM))
+casadi__Function__reverse__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__1 errStrPtrP x0' x1' x2' x3' o4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__1/c_casadi__Function__reverse__1" else wrapReturn o4''
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__1 :: FunctionClass a => a -> Vector DM -> Vector DM -> Vector (Vector DM) -> IO (Vector (Vector DM))
+function_reverse__1 x = casadi__Function__reverse__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__2" c_casadi__Function__reverse__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> CInt -> IO ()
+
+casadi__Function__reverse__2
+  :: Function -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> IO (Vector (Vector DM))
+casadi__Function__reverse__2 x0 x1 x2 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__2 errStrPtrP x0' x1' x2' x3' o4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__2/c_casadi__Function__reverse__2" else wrapReturn o4''
+  marshalFree x5 x5'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__2 :: FunctionClass a => a -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> IO (Vector (Vector DM))
+function_reverse__2 x = casadi__Function__reverse__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__3" c_casadi__Function__reverse__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr DM'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__reverse__3
+  :: Function -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> Bool -> IO (Vector (Vector DM))
+casadi__Function__reverse__3 x0 x1 x2 x3 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__3 errStrPtrP x0' x1' x2' x3' o4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__3/c_casadi__Function__reverse__3" else wrapReturn o4''
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__3 :: FunctionClass a => a -> Vector DM -> Vector DM -> Vector (Vector DM) -> Bool -> Bool -> IO (Vector (Vector DM))
+function_reverse__3 x = casadi__Function__reverse__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__4" c_casadi__Function__reverse__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> IO ()
+
+casadi__Function__reverse__4
+  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> IO (Vector (Vector SX))
+casadi__Function__reverse__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__4 errStrPtrP x0' x1' x2' x3' o4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__4/c_casadi__Function__reverse__4" else wrapReturn o4''
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> IO (Vector (Vector SX))
+function_reverse__4 x = casadi__Function__reverse__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__5" c_casadi__Function__reverse__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> CInt -> IO ()
+
+casadi__Function__reverse__5
+  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> IO (Vector (Vector SX))
+casadi__Function__reverse__5 x0 x1 x2 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__5 errStrPtrP x0' x1' x2' x3' o4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__5/c_casadi__Function__reverse__5" else wrapReturn o4''
+  marshalFree x5 x5'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> IO (Vector (Vector SX))
+function_reverse__5 x = casadi__Function__reverse__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__6" c_casadi__Function__reverse__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__reverse__6
+  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> Bool -> IO (Vector (Vector SX))
+casadi__Function__reverse__6 x0 x1 x2 x3 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__6 errStrPtrP x0' x1' x2' x3' o4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__6/c_casadi__Function__reverse__6" else wrapReturn o4''
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__6 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Bool -> Bool -> IO (Vector (Vector SX))
+function_reverse__6 x = casadi__Function__reverse__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__7" c_casadi__Function__reverse__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> IO ()
+
+casadi__Function__reverse__7
+  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> IO (Vector (Vector MX))
+casadi__Function__reverse__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__7 errStrPtrP x0' x1' x2' x3' o4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__7/c_casadi__Function__reverse__7" else wrapReturn o4''
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> IO (Vector (Vector MX))
+function_reverse__7 x = casadi__Function__reverse__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__8" c_casadi__Function__reverse__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> CInt -> IO ()
+
+casadi__Function__reverse__8
+  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> IO (Vector (Vector MX))
+casadi__Function__reverse__8 x0 x1 x2 x3 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__8 errStrPtrP x0' x1' x2' x3' o4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__8/c_casadi__Function__reverse__8" else wrapReturn o4''
+  marshalFree x5 x5'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> IO (Vector (Vector MX))
+function_reverse__8 x = casadi__Function__reverse__8 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__reverse__9" c_casadi__Function__reverse__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -> CInt -> CInt -> IO ()
+
+casadi__Function__reverse__9
+  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> Bool -> IO (Vector (Vector MX))
+casadi__Function__reverse__9 x0 x1 x2 x3 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  o4' <- new nullPtr
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__reverse__9 errStrPtrP x0' x1' x2' x3' o4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Function__reverse__9/c_casadi__Function__reverse__9" else wrapReturn o4''
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return (o4''')
+
+
+
+-- classy wrapper
+function_reverse__9 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Bool -> Bool -> IO (Vector (Vector MX))
+function_reverse__9 x = casadi__Function__reverse__9 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__rootfinder_fun" c_casadi__Function__rootfinder_fun
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__rootfinder_fun
+  :: Function -> IO Function
+casadi__Function__rootfinder_fun x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__rootfinder_fun errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_rootfinder_fun :: FunctionClass a => a -> IO Function
+function_rootfinder_fun x = casadi__Function__rootfinder_fun (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__rootfinder_jac" c_casadi__Function__rootfinder_jac
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__rootfinder_jac
+  :: Function -> IO Function
+casadi__Function__rootfinder_jac x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__rootfinder_jac errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_rootfinder_jac :: FunctionClass a => a -> IO Function
+function_rootfinder_jac x = casadi__Function__rootfinder_jac (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__rootfinder_linsol" c_casadi__Function__rootfinder_linsol
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__rootfinder_linsol
+  :: Function -> IO Function
+casadi__Function__rootfinder_linsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__rootfinder_linsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_rootfinder_linsol :: FunctionClass a => a -> IO Function
+function_rootfinder_linsol x = casadi__Function__rootfinder_linsol (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__setFullJacobian" c_casadi__Function__setFullJacobian
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO ()
+
+casadi__Function__setFullJacobian
+  :: Function -> Function -> IO ()
+casadi__Function__setFullJacobian x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__setFullJacobian errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_setFullJacobian :: FunctionClass a => a -> Function -> IO ()
+function_setFullJacobian x = casadi__Function__setFullJacobian (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__setJacobian__0" c_casadi__Function__setJacobian__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO ()
+
+casadi__Function__setJacobian__0
+  :: Function -> Function -> IO ()
+casadi__Function__setJacobian__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__setJacobian__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+function_setJacobian__0 :: FunctionClass a => a -> Function -> IO ()
+function_setJacobian__0 x = casadi__Function__setJacobian__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__setJacobian__1" c_casadi__Function__setJacobian__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO ()
+
+casadi__Function__setJacobian__1
+  :: Function -> Function -> Int -> IO ()
+casadi__Function__setJacobian__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__setJacobian__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+function_setJacobian__1 :: FunctionClass a => a -> Function -> Int -> IO ()
+function_setJacobian__1 x = casadi__Function__setJacobian__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__setJacobian__2" c_casadi__Function__setJacobian__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> IO ()
+
+casadi__Function__setJacobian__2
+  :: Function -> Function -> Int -> Int -> IO ()
+casadi__Function__setJacobian__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__setJacobian__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+function_setJacobian__2 :: FunctionClass a => a -> Function -> Int -> Int -> IO ()
+function_setJacobian__2 x = casadi__Function__setJacobian__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__setJacobian__3" c_casadi__Function__setJacobian__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> CInt -> IO ()
+
+casadi__Function__setJacobian__3
+  :: Function -> Function -> Int -> Int -> Bool -> IO ()
+casadi__Function__setJacobian__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__setJacobian__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+function_setJacobian__3 :: FunctionClass a => a -> Function -> Int -> Int -> Bool -> IO ()
+function_setJacobian__3 x = casadi__Function__setJacobian__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_forward" c_casadi__Function__set_forward
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO ()
+
+casadi__Function__set_forward
+  :: Function -> Function -> Int -> IO ()
+casadi__Function__set_forward x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_forward errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_forward :: FunctionClass a => a -> Function -> Int -> IO ()
+function_set_forward x = casadi__Function__set_forward (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__0" c_casadi__Function__set_jac_sparsity__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> IO ()
+
+casadi__Function__set_jac_sparsity__0
+  :: Function -> Sparsity -> String -> String -> IO ()
+casadi__Function__set_jac_sparsity__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__0 :: FunctionClass a => a -> Sparsity -> String -> String -> IO ()
+function_set_jac_sparsity__0 x = casadi__Function__set_jac_sparsity__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__1" c_casadi__Function__set_jac_sparsity__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> CInt -> IO ()
+
+casadi__Function__set_jac_sparsity__1
+  :: Function -> Sparsity -> String -> String -> Bool -> IO ()
+casadi__Function__set_jac_sparsity__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__1 :: FunctionClass a => a -> Sparsity -> String -> String -> Bool -> IO ()
+function_set_jac_sparsity__1 x = casadi__Function__set_jac_sparsity__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__2" c_casadi__Function__set_jac_sparsity__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> IO ()
+
+casadi__Function__set_jac_sparsity__2
+  :: Function -> Sparsity -> Int -> String -> IO ()
+casadi__Function__set_jac_sparsity__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__2 :: FunctionClass a => a -> Sparsity -> Int -> String -> IO ()
+function_set_jac_sparsity__2 x = casadi__Function__set_jac_sparsity__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__3" c_casadi__Function__set_jac_sparsity__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> CInt -> IO ()
+
+casadi__Function__set_jac_sparsity__3
+  :: Function -> Sparsity -> Int -> String -> Bool -> IO ()
+casadi__Function__set_jac_sparsity__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__3 :: FunctionClass a => a -> Sparsity -> Int -> String -> Bool -> IO ()
+function_set_jac_sparsity__3 x = casadi__Function__set_jac_sparsity__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__4" c_casadi__Function__set_jac_sparsity__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> IO ()
+
+casadi__Function__set_jac_sparsity__4
+  :: Function -> Sparsity -> String -> Int -> IO ()
+casadi__Function__set_jac_sparsity__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__4 :: FunctionClass a => a -> Sparsity -> String -> Int -> IO ()
+function_set_jac_sparsity__4 x = casadi__Function__set_jac_sparsity__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__5" c_casadi__Function__set_jac_sparsity__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> CInt -> IO ()
+
+casadi__Function__set_jac_sparsity__5
+  :: Function -> Sparsity -> String -> Int -> Bool -> IO ()
+casadi__Function__set_jac_sparsity__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__5 :: FunctionClass a => a -> Sparsity -> String -> Int -> Bool -> IO ()
+function_set_jac_sparsity__5 x = casadi__Function__set_jac_sparsity__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__6" c_casadi__Function__set_jac_sparsity__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> IO ()
+
+casadi__Function__set_jac_sparsity__6
+  :: Function -> Sparsity -> Int -> Int -> IO ()
+casadi__Function__set_jac_sparsity__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__6 :: FunctionClass a => a -> Sparsity -> Int -> Int -> IO ()
+function_set_jac_sparsity__6 x = casadi__Function__set_jac_sparsity__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_jac_sparsity__7" c_casadi__Function__set_jac_sparsity__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> CInt -> IO ()
+
+casadi__Function__set_jac_sparsity__7
+  :: Function -> Sparsity -> Int -> Int -> Bool -> IO ()
+casadi__Function__set_jac_sparsity__7 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_jac_sparsity__7 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_jac_sparsity__7 :: FunctionClass a => a -> Sparsity -> Int -> Int -> Bool -> IO ()
+function_set_jac_sparsity__7 x = casadi__Function__set_jac_sparsity__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__set_reverse" c_casadi__Function__set_reverse
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO ()
+
+casadi__Function__set_reverse
+  :: Function -> Function -> Int -> IO ()
+casadi__Function__set_reverse x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__set_reverse errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+function_set_reverse :: FunctionClass a => a -> Function -> Int -> IO ()
+function_set_reverse x = casadi__Function__set_reverse (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size1_in__0" c_casadi__Function__size1_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__size1_in__0
+  :: Function -> String -> IO Int
+casadi__Function__size1_in__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size1_in__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size1_in__0 :: FunctionClass a => a -> String -> IO Int
+function_size1_in__0 x = casadi__Function__size1_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size1_in__1" c_casadi__Function__size1_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__size1_in__1
+  :: Function -> Int -> IO Int
+casadi__Function__size1_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size1_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size1_in__1 :: FunctionClass a => a -> Int -> IO Int
+function_size1_in__1 x = casadi__Function__size1_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size1_out__0" c_casadi__Function__size1_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__size1_out__0
+  :: Function -> String -> IO Int
+casadi__Function__size1_out__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size1_out__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size1_out__0 :: FunctionClass a => a -> String -> IO Int
+function_size1_out__0 x = casadi__Function__size1_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size1_out__1" c_casadi__Function__size1_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__size1_out__1
+  :: Function -> Int -> IO Int
+casadi__Function__size1_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size1_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size1_out__1 :: FunctionClass a => a -> Int -> IO Int
+function_size1_out__1 x = casadi__Function__size1_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size2_in__0" c_casadi__Function__size2_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__size2_in__0
+  :: Function -> String -> IO Int
+casadi__Function__size2_in__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size2_in__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size2_in__0 :: FunctionClass a => a -> String -> IO Int
+function_size2_in__0 x = casadi__Function__size2_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size2_in__1" c_casadi__Function__size2_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__size2_in__1
+  :: Function -> Int -> IO Int
+casadi__Function__size2_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size2_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size2_in__1 :: FunctionClass a => a -> Int -> IO Int
+function_size2_in__1 x = casadi__Function__size2_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size2_out__0" c_casadi__Function__size2_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt
+
+casadi__Function__size2_out__0
+  :: Function -> String -> IO Int
+casadi__Function__size2_out__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size2_out__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size2_out__0 :: FunctionClass a => a -> String -> IO Int
+function_size2_out__0 x = casadi__Function__size2_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size2_out__1" c_casadi__Function__size2_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__size2_out__1
+  :: Function -> Int -> IO Int
+casadi__Function__size2_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size2_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size2_out__1 :: FunctionClass a => a -> Int -> IO Int
+function_size2_out__1 x = casadi__Function__size2_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size_in__0" c_casadi__Function__size_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr (StdPair CInt CInt))
+
+casadi__Function__size_in__0
+  :: Function -> String -> IO (Int, Int)
+casadi__Function__size_in__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size_in__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size_in__0 :: FunctionClass a => a -> String -> IO (Int, Int)
+function_size_in__0 x = casadi__Function__size_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size_in__1" c_casadi__Function__size_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr (StdPair CInt CInt))
+
+casadi__Function__size_in__1
+  :: Function -> Int -> IO (Int, Int)
+casadi__Function__size_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size_in__1 :: FunctionClass a => a -> Int -> IO (Int, Int)
+function_size_in__1 x = casadi__Function__size_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size_out__0" c_casadi__Function__size_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr (StdPair CInt CInt))
+
+casadi__Function__size_out__0
+  :: Function -> String -> IO (Int, Int)
+casadi__Function__size_out__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size_out__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size_out__0 :: FunctionClass a => a -> String -> IO (Int, Int)
+function_size_out__0 x = casadi__Function__size_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__size_out__1" c_casadi__Function__size_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr (StdPair CInt CInt))
+
+casadi__Function__size_out__1
+  :: Function -> Int -> IO (Int, Int)
+casadi__Function__size_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__size_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_size_out__1 :: FunctionClass a => a -> Int -> IO (Int, Int)
+function_size_out__1 x = casadi__Function__size_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__slice__0" c_casadi__Function__slice__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Function')
+
+casadi__Function__slice__0
+  :: Function -> Vector Int -> Vector Int -> IO Function
+casadi__Function__slice__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__slice__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_slice__0 :: FunctionClass a => a -> Vector Int -> Vector Int -> IO Function
+function_slice__0 x = casadi__Function__slice__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__slice__1" c_casadi__Function__slice__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+casadi__Function__slice__1
+  :: Function -> Vector Int -> Vector Int -> M.Map String GenericType -> IO Function
+casadi__Function__slice__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__slice__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_slice__1 :: FunctionClass a => a -> Vector Int -> Vector Int -> M.Map String GenericType -> IO Function
+function_slice__1 x = casadi__Function__slice__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__spCanEvaluate" c_casadi__Function__spCanEvaluate
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
+
+casadi__Function__spCanEvaluate
+  :: Function -> Bool -> IO Bool
+casadi__Function__spCanEvaluate x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__spCanEvaluate errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_spCanEvaluate :: FunctionClass a => a -> Bool -> IO Bool
+function_spCanEvaluate x = casadi__Function__spCanEvaluate (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_in__0" c_casadi__Function__sparsity_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_in__0
+  :: Function -> String -> IO Sparsity
+casadi__Function__sparsity_in__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_in__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_in__0 :: FunctionClass a => a -> String -> IO Sparsity
+function_sparsity_in__0 x = casadi__Function__sparsity_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_in__1" c_casadi__Function__sparsity_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_in__1
+  :: Function -> Int -> IO Sparsity
+casadi__Function__sparsity_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_in__1 :: FunctionClass a => a -> Int -> IO Sparsity
+function_sparsity_in__1 x = casadi__Function__sparsity_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__0" c_casadi__Function__sparsity_jac__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__0
+  :: Function -> String -> String -> IO Sparsity
+casadi__Function__sparsity_jac__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__0 :: FunctionClass a => a -> String -> String -> IO Sparsity
+function_sparsity_jac__0 x = casadi__Function__sparsity_jac__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__1" c_casadi__Function__sparsity_jac__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__1
+  :: Function -> String -> String -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Sparsity
+function_sparsity_jac__1 x = casadi__Function__sparsity_jac__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__2" c_casadi__Function__sparsity_jac__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__2
+  :: Function -> String -> String -> Bool -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Sparsity
+function_sparsity_jac__2 x = casadi__Function__sparsity_jac__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__3" c_casadi__Function__sparsity_jac__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__3
+  :: Function -> Int -> String -> IO Sparsity
+casadi__Function__sparsity_jac__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__3 :: FunctionClass a => a -> Int -> String -> IO Sparsity
+function_sparsity_jac__3 x = casadi__Function__sparsity_jac__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__4" c_casadi__Function__sparsity_jac__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__4
+  :: Function -> Int -> String -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Sparsity
+function_sparsity_jac__4 x = casadi__Function__sparsity_jac__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__5" c_casadi__Function__sparsity_jac__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__5
+  :: Function -> Int -> String -> Bool -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Sparsity
+function_sparsity_jac__5 x = casadi__Function__sparsity_jac__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__6" c_casadi__Function__sparsity_jac__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__6
+  :: Function -> String -> IO Sparsity
+casadi__Function__sparsity_jac__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__6 :: FunctionClass a => a -> String -> IO Sparsity
+function_sparsity_jac__6 x = casadi__Function__sparsity_jac__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__7" c_casadi__Function__sparsity_jac__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__7
+  :: Function -> String -> Int -> IO Sparsity
+casadi__Function__sparsity_jac__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__7 :: FunctionClass a => a -> String -> Int -> IO Sparsity
+function_sparsity_jac__7 x = casadi__Function__sparsity_jac__7 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__8" c_casadi__Function__sparsity_jac__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__8
+  :: Function -> String -> Int -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Sparsity
+function_sparsity_jac__8 x = casadi__Function__sparsity_jac__8 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__9" c_casadi__Function__sparsity_jac__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__9
+  :: Function -> String -> Int -> Bool -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__9 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__9 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Sparsity
+function_sparsity_jac__9 x = casadi__Function__sparsity_jac__9 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__10" c_casadi__Function__sparsity_jac__10
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__10
+  :: Function -> IO Sparsity
+casadi__Function__sparsity_jac__10 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__10 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__10 :: FunctionClass a => a -> IO Sparsity
+function_sparsity_jac__10 x = casadi__Function__sparsity_jac__10 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__11" c_casadi__Function__sparsity_jac__11
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__11
+  :: Function -> Int -> IO Sparsity
+casadi__Function__sparsity_jac__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__11 :: FunctionClass a => a -> Int -> IO Sparsity
+function_sparsity_jac__11 x = casadi__Function__sparsity_jac__11 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__12" c_casadi__Function__sparsity_jac__12
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__12
+  :: Function -> Int -> Int -> IO Sparsity
+casadi__Function__sparsity_jac__12 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__12 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__12 :: FunctionClass a => a -> Int -> Int -> IO Sparsity
+function_sparsity_jac__12 x = casadi__Function__sparsity_jac__12 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__13" c_casadi__Function__sparsity_jac__13
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__13
+  :: Function -> Int -> Int -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__13 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__13 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Sparsity
+function_sparsity_jac__13 x = casadi__Function__sparsity_jac__13 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_jac__14" c_casadi__Function__sparsity_jac__14
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_jac__14
+  :: Function -> Int -> Int -> Bool -> Bool -> IO Sparsity
+casadi__Function__sparsity_jac__14 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_jac__14 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_jac__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Sparsity
+function_sparsity_jac__14 x = casadi__Function__sparsity_jac__14 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_out__0" c_casadi__Function__sparsity_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_out__0
+  :: Function -> String -> IO Sparsity
+casadi__Function__sparsity_out__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_out__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_out__0 :: FunctionClass a => a -> String -> IO Sparsity
+function_sparsity_out__0 x = casadi__Function__sparsity_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sparsity_out__1" c_casadi__Function__sparsity_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Function__sparsity_out__1
+  :: Function -> Int -> IO Sparsity
+casadi__Function__sparsity_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sparsity_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sparsity_out__1 :: FunctionClass a => a -> Int -> IO Sparsity
+function_sparsity_out__1 x = casadi__Function__sparsity_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__stats__0" c_casadi__Function__stats__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdMap StdString (Ptr GenericType')))
+
+casadi__Function__stats__0
+  :: Function -> IO (M.Map String GenericType)
+casadi__Function__stats__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__stats__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_stats__0 :: FunctionClass a => a -> IO (M.Map String GenericType)
+function_stats__0 x = casadi__Function__stats__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__stats__1" c_casadi__Function__stats__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr (StdMap StdString (Ptr GenericType')))
+
+casadi__Function__stats__1
+  :: Function -> Int -> IO (M.Map String GenericType)
+casadi__Function__stats__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__stats__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_stats__1 :: FunctionClass a => a -> Int -> IO (M.Map String GenericType)
+function_stats__1 x = casadi__Function__stats__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sx_in__0" c_casadi__Function__sx_in__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi__Function__sx_in__0
+  :: Function -> IO (Vector SX)
+casadi__Function__sx_in__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sx_in__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sx_in__0 :: FunctionClass a => a -> IO (Vector SX)
+function_sx_in__0 x = casadi__Function__sx_in__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sx_in__1" c_casadi__Function__sx_in__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr SX')
+
+casadi__Function__sx_in__1
+  :: Function -> String -> IO SX
+casadi__Function__sx_in__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sx_in__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sx_in__1 :: FunctionClass a => a -> String -> IO SX
+function_sx_in__1 x = casadi__Function__sx_in__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sx_in__2" c_casadi__Function__sx_in__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr SX')
+
+casadi__Function__sx_in__2
+  :: Function -> Int -> IO SX
+casadi__Function__sx_in__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sx_in__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sx_in__2 :: FunctionClass a => a -> Int -> IO SX
+function_sx_in__2 x = casadi__Function__sx_in__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sx_out__0" c_casadi__Function__sx_out__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi__Function__sx_out__0
+  :: Function -> IO (Vector SX)
+casadi__Function__sx_out__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sx_out__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sx_out__0 :: FunctionClass a => a -> IO (Vector SX)
+function_sx_out__0 x = casadi__Function__sx_out__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sx_out__1" c_casadi__Function__sx_out__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr SX')
+
+casadi__Function__sx_out__1
+  :: Function -> String -> IO SX
+casadi__Function__sx_out__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sx_out__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sx_out__1 :: FunctionClass a => a -> String -> IO SX
+function_sx_out__1 x = casadi__Function__sx_out__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sx_out__2" c_casadi__Function__sx_out__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr SX')
+
+casadi__Function__sx_out__2
+  :: Function -> Int -> IO SX
+casadi__Function__sx_out__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sx_out__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sx_out__2 :: FunctionClass a => a -> Int -> IO SX
+function_sx_out__2 x = casadi__Function__sx_out__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sz_arg" c_casadi__Function__sz_arg
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
+
+casadi__Function__sz_arg
+  :: Function -> IO CSize
+casadi__Function__sz_arg x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sz_arg errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sz_arg :: FunctionClass a => a -> IO CSize
+function_sz_arg x = casadi__Function__sz_arg (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sz_iw" c_casadi__Function__sz_iw
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
+
+casadi__Function__sz_iw
+  :: Function -> IO CSize
+casadi__Function__sz_iw x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sz_iw errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sz_iw :: FunctionClass a => a -> IO CSize
+function_sz_iw x = casadi__Function__sz_iw (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sz_res" c_casadi__Function__sz_res
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
+
+casadi__Function__sz_res
+  :: Function -> IO CSize
+casadi__Function__sz_res x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sz_res errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sz_res :: FunctionClass a => a -> IO CSize
+function_sz_res x = casadi__Function__sz_res (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__sz_w" c_casadi__Function__sz_w
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize
+
+casadi__Function__sz_w
+  :: Function -> IO CSize
+casadi__Function__sz_w x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__sz_w errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_sz_w :: FunctionClass a => a -> IO CSize
+function_sz_w x = casadi__Function__sz_w (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__tangent__0" c_casadi__Function__tangent__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__tangent__0
+  :: Function -> String -> String -> IO Function
+casadi__Function__tangent__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__tangent__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_tangent__0 :: FunctionClass a => a -> String -> String -> IO Function
+function_tangent__0 x = casadi__Function__tangent__0 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__tangent__1" c_casadi__Function__tangent__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__tangent__1
+  :: Function -> Int -> String -> IO Function
+casadi__Function__tangent__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__tangent__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_tangent__1 :: FunctionClass a => a -> Int -> String -> IO Function
+function_tangent__1 x = casadi__Function__tangent__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__tangent__2" c_casadi__Function__tangent__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+
+casadi__Function__tangent__2
+  :: Function -> String -> IO Function
+casadi__Function__tangent__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__tangent__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_tangent__2 :: FunctionClass a => a -> String -> IO Function
+function_tangent__2 x = casadi__Function__tangent__2 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__tangent__3" c_casadi__Function__tangent__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
+
+casadi__Function__tangent__3
+  :: Function -> String -> Int -> IO Function
+casadi__Function__tangent__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__tangent__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_tangent__3 :: FunctionClass a => a -> String -> Int -> IO Function
+function_tangent__3 x = casadi__Function__tangent__3 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__tangent__4" c_casadi__Function__tangent__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+casadi__Function__tangent__4
+  :: Function -> IO Function
+casadi__Function__tangent__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__tangent__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_tangent__4 :: FunctionClass a => a -> IO Function
+function_tangent__4 x = casadi__Function__tangent__4 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__tangent__5" c_casadi__Function__tangent__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+casadi__Function__tangent__5
+  :: Function -> Int -> IO Function
+casadi__Function__tangent__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__tangent__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+function_tangent__5 :: FunctionClass a => a -> Int -> IO Function
+function_tangent__5 x = casadi__Function__tangent__5 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall safe "casadi__Function__tangent__6" c_casadi__Function__tangent__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
+
+casadi__Function__tangent__6
+  :: Function -> Int -> Int -> IO Function
+casadi__Function__tangent__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__tangent__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+function_tangent__6 :: FunctionClass a => a -> Int -> Int -> IO Function
+function_tangent__6 x = casadi__Function__tangent__6 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__type_name" c_casadi__Function__type_name
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString)
+
+casadi__Function__type_name
+  :: Function -> IO String
+casadi__Function__type_name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Function__type_name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+function_type_name :: FunctionClass a => a -> IO String
+function_type_name x = casadi__Function__type_name (castFunction x)
 
diff --git a/Casadi/Core/Classes/Functor.hs b/Casadi/Core/Classes/Functor.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/Functor.hs
+++ /dev/null
@@ -1,31 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.Functor
-       (
-         Functor,
-         FunctorClass(..),
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
diff --git a/Casadi/Core/Classes/GenericExpressionCommon.hs b/Casadi/Core/Classes/GenericExpressionCommon.hs
--- a/Casadi/Core/Classes/GenericExpressionCommon.hs
+++ b/Casadi/Core/Classes/GenericExpressionCommon.hs
@@ -25,7 +25,7 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
diff --git a/Casadi/Core/Classes/GenericMatrixCommon.hs b/Casadi/Core/Classes/GenericMatrixCommon.hs
--- a/Casadi/Core/Classes/GenericMatrixCommon.hs
+++ b/Casadi/Core/Classes/GenericMatrixCommon.hs
@@ -25,7 +25,7 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
diff --git a/Casadi/Core/Classes/GenericType.hs b/Casadi/Core/Classes/GenericType.hs
--- a/Casadi/Core/Classes/GenericType.hs
+++ b/Casadi/Core/Classes/GenericType.hs
@@ -13,1009 +13,1450 @@
          genericType__1,
          genericType__10,
          genericType__11,
-         genericType__12,
-         genericType__13,
-         genericType__2,
-         genericType__3,
-         genericType__4,
-         genericType__5,
-         genericType__6,
-         genericType__7,
-         genericType__8,
-         genericType__9,
-         genericType_can_cast_to__0,
-         genericType_can_cast_to__1,
-         genericType_from_type,
-         genericType_getType,
-         genericType_get_description,
-         genericType_get_type_description,
-         genericType_isBool,
-         genericType_isCallback,
-         genericType_isDerivativeGenerator,
-         genericType_isDict,
-         genericType_isDouble,
-         genericType_isDoubleVector,
-         genericType_isFunction,
-         genericType_isInt,
-         genericType_isIntVector,
-         genericType_isIntVectorVector,
-         genericType_isString,
-         genericType_isStringVector,
-         genericType_isVoidPointer,
-         genericType_isemptyVector,
-         genericType_operator_equals,
-         genericType_operator_nequals,
-         genericType_toBool,
-         genericType_toDict,
-         genericType_toDouble,
-         genericType_toDoubleVector,
-         genericType_toFunction,
-         genericType_toInt,
-         genericType_toIntVector,
-         genericType_toIntVectorVector,
-         genericType_toString,
-         genericType_toStringVector,
-         genericType_toVoidPointer,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__0" c_casadi__GenericType__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__0
-  :: M.Map String GenericType -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__0 :: M.Map String GenericType -> IO GenericType
-genericType__0 = casadi__GenericType__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__1" c_casadi__GenericType__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr Callback' -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__1
-  :: Callback -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__1 :: Callback -> IO GenericType
-genericType__1 = casadi__GenericType__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__2" c_casadi__GenericType__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator' -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__2
-  :: DerivativeGenerator -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__2 :: DerivativeGenerator -> IO GenericType
-genericType__2 = casadi__GenericType__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__3" c_casadi__GenericType__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__3
-  :: Function -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__3 :: Function -> IO GenericType
-genericType__3 = casadi__GenericType__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__4" c_casadi__GenericType__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__4
-  :: Vector String -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__4 :: Vector String -> IO GenericType
-genericType__4 = casadi__GenericType__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__5" c_casadi__GenericType__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__5
-  :: Vector Double -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__5 :: Vector Double -> IO GenericType
-genericType__5 = casadi__GenericType__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__6" c_casadi__GenericType__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CInt))) -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__6
-  :: Vector (Vector Int) -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__6 :: Vector (Vector Int) -> IO GenericType
-genericType__6 = casadi__GenericType__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__7" c_casadi__GenericType__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__7
-  :: Vector Int -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__7 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__7 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__7 :: Vector Int -> IO GenericType
-genericType__7 = casadi__GenericType__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__8" c_casadi__GenericType__CONSTRUCTOR__8
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__8
-  :: Vector Bool -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__8 :: Vector Bool -> IO GenericType
-genericType__8 = casadi__GenericType__CONSTRUCTOR__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__9" c_casadi__GenericType__CONSTRUCTOR__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__9
-  :: String -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__9 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__9 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__9 :: String -> IO GenericType
-genericType__9 = casadi__GenericType__CONSTRUCTOR__9
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__10" c_casadi__GenericType__CONSTRUCTOR__10
-  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__10
-  :: Double -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__10 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__10 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__10 :: Double -> IO GenericType
-genericType__10 = casadi__GenericType__CONSTRUCTOR__10
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__11" c_casadi__GenericType__CONSTRUCTOR__11
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__11
-  :: Int -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__11 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__11 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__11 :: Int -> IO GenericType
-genericType__11 = casadi__GenericType__CONSTRUCTOR__11
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__12" c_casadi__GenericType__CONSTRUCTOR__12
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__12
-  :: Bool -> IO GenericType
-casadi__GenericType__CONSTRUCTOR__12 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__12 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__12 :: Bool -> IO GenericType
-genericType__12 = casadi__GenericType__CONSTRUCTOR__12
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__13" c_casadi__GenericType__CONSTRUCTOR__13
-  :: Ptr (Ptr StdString) -> IO (Ptr GenericType')
-casadi__GenericType__CONSTRUCTOR__13
-  :: IO GenericType
-casadi__GenericType__CONSTRUCTOR__13  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__CONSTRUCTOR__13 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType__13 :: IO GenericType
-genericType__13 = casadi__GenericType__CONSTRUCTOR__13
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__can_cast_to__0" c_casadi__GenericType__can_cast_to__0
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> Ptr GenericType' -> IO CInt
-casadi__GenericType__can_cast_to__0
-  :: GenericType -> GenericType -> IO Bool
-casadi__GenericType__can_cast_to__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__can_cast_to__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_can_cast_to__0 :: GenericTypeClass a => a -> GenericType -> IO Bool
-genericType_can_cast_to__0 x = casadi__GenericType__can_cast_to__0 (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__can_cast_to__1" c_casadi__GenericType__can_cast_to__1
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> CInt -> IO CInt
-casadi__GenericType__can_cast_to__1
-  :: GenericType -> TypeID -> IO Bool
-casadi__GenericType__can_cast_to__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__can_cast_to__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_can_cast_to__1 :: GenericTypeClass a => a -> TypeID -> IO Bool
-genericType_can_cast_to__1 x = casadi__GenericType__can_cast_to__1 (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__from_type" c_casadi__GenericType__from_type
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr GenericType')
-casadi__GenericType__from_type
-  :: TypeID -> IO GenericType
-casadi__GenericType__from_type x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__from_type errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_from_type :: TypeID -> IO GenericType
-genericType_from_type = casadi__GenericType__from_type
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__getType" c_casadi__GenericType__getType
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__getType
-  :: GenericType -> IO TypeID
-casadi__GenericType__getType x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__getType errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_getType :: GenericTypeClass a => a -> IO TypeID
-genericType_getType x = casadi__GenericType__getType (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__get_description" c_casadi__GenericType__get_description
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr StdString)
-casadi__GenericType__get_description
-  :: GenericType -> IO String
-casadi__GenericType__get_description x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__get_description errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_get_description :: GenericTypeClass a => a -> IO String
-genericType_get_description x = casadi__GenericType__get_description (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__get_type_description" c_casadi__GenericType__get_type_description
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
-casadi__GenericType__get_type_description
-  :: TypeID -> IO String
-casadi__GenericType__get_type_description x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__get_type_description errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_get_type_description :: TypeID -> IO String
-genericType_get_type_description = casadi__GenericType__get_type_description
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isBool" c_casadi__GenericType__isBool
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isBool
-  :: GenericType -> IO Bool
-casadi__GenericType__isBool x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isBool errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isBool :: GenericTypeClass a => a -> IO Bool
-genericType_isBool x = casadi__GenericType__isBool (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isCallback" c_casadi__GenericType__isCallback
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isCallback
-  :: GenericType -> IO Bool
-casadi__GenericType__isCallback x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isCallback errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isCallback :: GenericTypeClass a => a -> IO Bool
-genericType_isCallback x = casadi__GenericType__isCallback (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isDerivativeGenerator" c_casadi__GenericType__isDerivativeGenerator
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isDerivativeGenerator
-  :: GenericType -> IO Bool
-casadi__GenericType__isDerivativeGenerator x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isDerivativeGenerator errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isDerivativeGenerator :: GenericTypeClass a => a -> IO Bool
-genericType_isDerivativeGenerator x = casadi__GenericType__isDerivativeGenerator (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isDict" c_casadi__GenericType__isDict
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isDict
-  :: GenericType -> IO Bool
-casadi__GenericType__isDict x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isDict errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isDict :: GenericTypeClass a => a -> IO Bool
-genericType_isDict x = casadi__GenericType__isDict (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isDouble" c_casadi__GenericType__isDouble
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isDouble
-  :: GenericType -> IO Bool
-casadi__GenericType__isDouble x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isDouble errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isDouble :: GenericTypeClass a => a -> IO Bool
-genericType_isDouble x = casadi__GenericType__isDouble (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isDoubleVector" c_casadi__GenericType__isDoubleVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isDoubleVector
-  :: GenericType -> IO Bool
-casadi__GenericType__isDoubleVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isDoubleVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isDoubleVector :: GenericTypeClass a => a -> IO Bool
-genericType_isDoubleVector x = casadi__GenericType__isDoubleVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isFunction" c_casadi__GenericType__isFunction
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isFunction
-  :: GenericType -> IO Bool
-casadi__GenericType__isFunction x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isFunction errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isFunction :: GenericTypeClass a => a -> IO Bool
-genericType_isFunction x = casadi__GenericType__isFunction (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isInt" c_casadi__GenericType__isInt
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isInt
-  :: GenericType -> IO Bool
-casadi__GenericType__isInt x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isInt errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isInt :: GenericTypeClass a => a -> IO Bool
-genericType_isInt x = casadi__GenericType__isInt (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isIntVector" c_casadi__GenericType__isIntVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isIntVector
-  :: GenericType -> IO Bool
-casadi__GenericType__isIntVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isIntVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isIntVector :: GenericTypeClass a => a -> IO Bool
-genericType_isIntVector x = casadi__GenericType__isIntVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isIntVectorVector" c_casadi__GenericType__isIntVectorVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isIntVectorVector
-  :: GenericType -> IO Bool
-casadi__GenericType__isIntVectorVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isIntVectorVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isIntVectorVector :: GenericTypeClass a => a -> IO Bool
-genericType_isIntVectorVector x = casadi__GenericType__isIntVectorVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isString" c_casadi__GenericType__isString
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isString
-  :: GenericType -> IO Bool
-casadi__GenericType__isString x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isString errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isString :: GenericTypeClass a => a -> IO Bool
-genericType_isString x = casadi__GenericType__isString (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isStringVector" c_casadi__GenericType__isStringVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isStringVector
-  :: GenericType -> IO Bool
-casadi__GenericType__isStringVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isStringVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isStringVector :: GenericTypeClass a => a -> IO Bool
-genericType_isStringVector x = casadi__GenericType__isStringVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isVoidPointer" c_casadi__GenericType__isVoidPointer
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isVoidPointer
-  :: GenericType -> IO Bool
-casadi__GenericType__isVoidPointer x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isVoidPointer errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isVoidPointer :: GenericTypeClass a => a -> IO Bool
-genericType_isVoidPointer x = casadi__GenericType__isVoidPointer (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__isemptyVector" c_casadi__GenericType__isemptyVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__isemptyVector
-  :: GenericType -> IO Bool
-casadi__GenericType__isemptyVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__isemptyVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_isemptyVector :: GenericTypeClass a => a -> IO Bool
-genericType_isemptyVector x = casadi__GenericType__isemptyVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__operator_nequals" c_casadi__GenericType__operator_nequals
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> Ptr GenericType' -> IO CInt
-casadi__GenericType__operator_nequals
-  :: GenericType -> GenericType -> IO Bool
-casadi__GenericType__operator_nequals x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__operator_nequals errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_operator_nequals :: GenericTypeClass a => a -> GenericType -> IO Bool
-genericType_operator_nequals x = casadi__GenericType__operator_nequals (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__operator_equals" c_casadi__GenericType__operator_equals
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> Ptr GenericType' -> IO CInt
-casadi__GenericType__operator_equals
-  :: GenericType -> GenericType -> IO Bool
-casadi__GenericType__operator_equals x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__operator_equals errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_operator_equals :: GenericTypeClass a => a -> GenericType -> IO Bool
-genericType_operator_equals x = casadi__GenericType__operator_equals (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toBool" c_casadi__GenericType__toBool
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__toBool
-  :: GenericType -> IO Bool
-casadi__GenericType__toBool x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toBool errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toBool :: GenericTypeClass a => a -> IO Bool
-genericType_toBool x = casadi__GenericType__toBool (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toDict" c_casadi__GenericType__toDict
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdMap StdString (Ptr GenericType')))
-casadi__GenericType__toDict
-  :: GenericType -> IO (M.Map String GenericType)
-casadi__GenericType__toDict x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toDict errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toDict :: GenericTypeClass a => a -> IO (M.Map String GenericType)
-genericType_toDict x = casadi__GenericType__toDict (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toDouble" c_casadi__GenericType__toDouble
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CDouble
-casadi__GenericType__toDouble
-  :: GenericType -> IO Double
-casadi__GenericType__toDouble x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toDouble errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toDouble :: GenericTypeClass a => a -> IO Double
-genericType_toDouble x = casadi__GenericType__toDouble (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toDoubleVector" c_casadi__GenericType__toDoubleVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec CDouble))
-casadi__GenericType__toDoubleVector
-  :: GenericType -> IO (Vector Double)
-casadi__GenericType__toDoubleVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toDoubleVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toDoubleVector :: GenericTypeClass a => a -> IO (Vector Double)
-genericType_toDoubleVector x = casadi__GenericType__toDoubleVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toFunction" c_casadi__GenericType__toFunction
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr Function')
-casadi__GenericType__toFunction
-  :: GenericType -> IO Function
-casadi__GenericType__toFunction x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toFunction errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toFunction :: GenericTypeClass a => a -> IO Function
-genericType_toFunction x = casadi__GenericType__toFunction (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toInt" c_casadi__GenericType__toInt
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
-casadi__GenericType__toInt
-  :: GenericType -> IO Int
-casadi__GenericType__toInt x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toInt errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toInt :: GenericTypeClass a => a -> IO Int
-genericType_toInt x = casadi__GenericType__toInt (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toIntVector" c_casadi__GenericType__toIntVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec CInt))
-casadi__GenericType__toIntVector
-  :: GenericType -> IO (Vector Int)
-casadi__GenericType__toIntVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toIntVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toIntVector :: GenericTypeClass a => a -> IO (Vector Int)
-genericType_toIntVector x = casadi__GenericType__toIntVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toIntVectorVector" c_casadi__GenericType__toIntVectorVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec (Ptr (StdVec CInt))))
-casadi__GenericType__toIntVectorVector
-  :: GenericType -> IO (Vector (Vector Int))
-casadi__GenericType__toIntVectorVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toIntVectorVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toIntVectorVector :: GenericTypeClass a => a -> IO (Vector (Vector Int))
-genericType_toIntVectorVector x = casadi__GenericType__toIntVectorVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toString" c_casadi__GenericType__toString
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr StdString)
-casadi__GenericType__toString
-  :: GenericType -> IO String
-casadi__GenericType__toString x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toString errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toString :: GenericTypeClass a => a -> IO String
-genericType_toString x = casadi__GenericType__toString (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toStringVector" c_casadi__GenericType__toStringVector
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec (Ptr StdString)))
-casadi__GenericType__toStringVector
-  :: GenericType -> IO (Vector String)
-casadi__GenericType__toStringVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toStringVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toStringVector :: GenericTypeClass a => a -> IO (Vector String)
-genericType_toStringVector x = casadi__GenericType__toStringVector (castGenericType x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__GenericType__toVoidPointer" c_casadi__GenericType__toVoidPointer
-  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO ()
-casadi__GenericType__toVoidPointer
-  :: GenericType -> IO ()
-casadi__GenericType__toVoidPointer x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__GenericType__toVoidPointer errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-genericType_toVoidPointer :: GenericTypeClass a => a -> IO ()
-genericType_toVoidPointer x = casadi__GenericType__toVoidPointer (castGenericType x)
+         genericType__2,
+         genericType__3,
+         genericType__4,
+         genericType__5,
+         genericType__6,
+         genericType__7,
+         genericType__8,
+         genericType__9,
+         genericType_as_bool,
+         genericType_as_dict,
+         genericType_as_double,
+         genericType_as_double_vector,
+         genericType_as_function,
+         genericType_as_int,
+         genericType_as_int_vector,
+         genericType_as_int_vector_vector,
+         genericType_as_string,
+         genericType_as_string_vector,
+         genericType_as_void_pointer,
+         genericType_getType,
+         genericType_get_description,
+         genericType_is_bool,
+         genericType_is_dict,
+         genericType_is_double,
+         genericType_is_double_vector,
+         genericType_is_empty_vector,
+         genericType_is_function,
+         genericType_is_int,
+         genericType_is_int_vector,
+         genericType_is_int_vector_vector,
+         genericType_is_string,
+         genericType_is_string_vector,
+         genericType_is_void_pointer,
+         genericType_operator__equals,
+         genericType_operator__nequals,
+         genericType_to_bool,
+         genericType_to_bool_vector,
+         genericType_to_dict,
+         genericType_to_double,
+         genericType_to_double_vector,
+         genericType_to_function,
+         genericType_to_int,
+         genericType_to_int_vector,
+         genericType_to_int_vector_vector,
+         genericType_to_string,
+         genericType_to_string_vector,
+         genericType_to_void_pointer,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__0" c_casadi__GenericType__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__0
+  :: M.Map String GenericType -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__0 :: M.Map String GenericType -> IO GenericType
+genericType__0 = casadi__GenericType__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__1" c_casadi__GenericType__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__1
+  :: Function -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__1 :: Function -> IO GenericType
+genericType__1 = casadi__GenericType__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__2" c_casadi__GenericType__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__2
+  :: Vector String -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__2 :: Vector String -> IO GenericType
+genericType__2 = casadi__GenericType__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__3" c_casadi__GenericType__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__3
+  :: Vector Double -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__3 :: Vector Double -> IO GenericType
+genericType__3 = casadi__GenericType__CONSTRUCTOR__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__4" c_casadi__GenericType__CONSTRUCTOR__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CInt))) -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__4
+  :: Vector (Vector Int) -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__4 :: Vector (Vector Int) -> IO GenericType
+genericType__4 = casadi__GenericType__CONSTRUCTOR__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__5" c_casadi__GenericType__CONSTRUCTOR__5
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__5
+  :: Vector Int -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__5 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__5 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__5 :: Vector Int -> IO GenericType
+genericType__5 = casadi__GenericType__CONSTRUCTOR__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__6" c_casadi__GenericType__CONSTRUCTOR__6
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__6
+  :: Vector Bool -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__6 :: Vector Bool -> IO GenericType
+genericType__6 = casadi__GenericType__CONSTRUCTOR__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__7" c_casadi__GenericType__CONSTRUCTOR__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__7
+  :: String -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__7 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__7 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__7 :: String -> IO GenericType
+genericType__7 = casadi__GenericType__CONSTRUCTOR__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__8" c_casadi__GenericType__CONSTRUCTOR__8
+  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__8
+  :: Double -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__8 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__8 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__8 :: Double -> IO GenericType
+genericType__8 = casadi__GenericType__CONSTRUCTOR__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__9" c_casadi__GenericType__CONSTRUCTOR__9
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__9
+  :: Int -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__9 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__9 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__9 :: Int -> IO GenericType
+genericType__9 = casadi__GenericType__CONSTRUCTOR__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__10" c_casadi__GenericType__CONSTRUCTOR__10
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__10
+  :: Bool -> IO GenericType
+casadi__GenericType__CONSTRUCTOR__10 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__10 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__10 :: Bool -> IO GenericType
+genericType__10 = casadi__GenericType__CONSTRUCTOR__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__11" c_casadi__GenericType__CONSTRUCTOR__11
+  :: Ptr (Ptr StdString) -> IO (Ptr GenericType')
+
+casadi__GenericType__CONSTRUCTOR__11
+  :: IO GenericType
+casadi__GenericType__CONSTRUCTOR__11  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__CONSTRUCTOR__11 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+genericType__11 :: IO GenericType
+genericType__11 = casadi__GenericType__CONSTRUCTOR__11
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_bool" c_casadi__GenericType__as_bool
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__as_bool
+  :: GenericType -> IO Bool
+casadi__GenericType__as_bool x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_bool errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_bool :: GenericTypeClass a => a -> IO Bool
+genericType_as_bool x = casadi__GenericType__as_bool (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_dict" c_casadi__GenericType__as_dict
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdMap StdString (Ptr GenericType')))
+
+casadi__GenericType__as_dict
+  :: GenericType -> IO (M.Map String GenericType)
+casadi__GenericType__as_dict x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_dict errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_dict :: GenericTypeClass a => a -> IO (M.Map String GenericType)
+genericType_as_dict x = casadi__GenericType__as_dict (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_double" c_casadi__GenericType__as_double
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CDouble
+
+casadi__GenericType__as_double
+  :: GenericType -> IO Double
+casadi__GenericType__as_double x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_double errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_double :: GenericTypeClass a => a -> IO Double
+genericType_as_double x = casadi__GenericType__as_double (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_double_vector" c_casadi__GenericType__as_double_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec CDouble))
+
+casadi__GenericType__as_double_vector
+  :: GenericType -> IO (Vector Double)
+casadi__GenericType__as_double_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_double_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_double_vector :: GenericTypeClass a => a -> IO (Vector Double)
+genericType_as_double_vector x = casadi__GenericType__as_double_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_function" c_casadi__GenericType__as_function
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr Function')
+
+casadi__GenericType__as_function
+  :: GenericType -> IO Function
+casadi__GenericType__as_function x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_function errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_function :: GenericTypeClass a => a -> IO Function
+genericType_as_function x = casadi__GenericType__as_function (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_int" c_casadi__GenericType__as_int
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__as_int
+  :: GenericType -> IO Int
+casadi__GenericType__as_int x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_int errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_int :: GenericTypeClass a => a -> IO Int
+genericType_as_int x = casadi__GenericType__as_int (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_int_vector" c_casadi__GenericType__as_int_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec CInt))
+
+casadi__GenericType__as_int_vector
+  :: GenericType -> IO (Vector Int)
+casadi__GenericType__as_int_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_int_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_int_vector :: GenericTypeClass a => a -> IO (Vector Int)
+genericType_as_int_vector x = casadi__GenericType__as_int_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_int_vector_vector" c_casadi__GenericType__as_int_vector_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec (Ptr (StdVec CInt))))
+
+casadi__GenericType__as_int_vector_vector
+  :: GenericType -> IO (Vector (Vector Int))
+casadi__GenericType__as_int_vector_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_int_vector_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_int_vector_vector :: GenericTypeClass a => a -> IO (Vector (Vector Int))
+genericType_as_int_vector_vector x = casadi__GenericType__as_int_vector_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_string" c_casadi__GenericType__as_string
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr StdString)
+
+casadi__GenericType__as_string
+  :: GenericType -> IO String
+casadi__GenericType__as_string x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_string errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_string :: GenericTypeClass a => a -> IO String
+genericType_as_string x = casadi__GenericType__as_string (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_string_vector" c_casadi__GenericType__as_string_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec (Ptr StdString)))
+
+casadi__GenericType__as_string_vector
+  :: GenericType -> IO (Vector String)
+casadi__GenericType__as_string_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_string_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_as_string_vector :: GenericTypeClass a => a -> IO (Vector String)
+genericType_as_string_vector x = casadi__GenericType__as_string_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__as_void_pointer" c_casadi__GenericType__as_void_pointer
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO ()
+
+casadi__GenericType__as_void_pointer
+  :: GenericType -> IO ()
+casadi__GenericType__as_void_pointer x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__as_void_pointer errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+genericType_as_void_pointer :: GenericTypeClass a => a -> IO ()
+genericType_as_void_pointer x = casadi__GenericType__as_void_pointer (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__getType" c_casadi__GenericType__getType
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__getType
+  :: GenericType -> IO TypeID
+casadi__GenericType__getType x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__getType errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_getType :: GenericTypeClass a => a -> IO TypeID
+genericType_getType x = casadi__GenericType__getType (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__get_description" c_casadi__GenericType__get_description
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr StdString)
+
+casadi__GenericType__get_description
+  :: GenericType -> IO String
+casadi__GenericType__get_description x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__get_description errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_get_description :: GenericTypeClass a => a -> IO String
+genericType_get_description x = casadi__GenericType__get_description (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_bool" c_casadi__GenericType__is_bool
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_bool
+  :: GenericType -> IO Bool
+casadi__GenericType__is_bool x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_bool errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_bool :: GenericTypeClass a => a -> IO Bool
+genericType_is_bool x = casadi__GenericType__is_bool (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_dict" c_casadi__GenericType__is_dict
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_dict
+  :: GenericType -> IO Bool
+casadi__GenericType__is_dict x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_dict errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_dict :: GenericTypeClass a => a -> IO Bool
+genericType_is_dict x = casadi__GenericType__is_dict (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_double" c_casadi__GenericType__is_double
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_double
+  :: GenericType -> IO Bool
+casadi__GenericType__is_double x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_double errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_double :: GenericTypeClass a => a -> IO Bool
+genericType_is_double x = casadi__GenericType__is_double (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_double_vector" c_casadi__GenericType__is_double_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_double_vector
+  :: GenericType -> IO Bool
+casadi__GenericType__is_double_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_double_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_double_vector :: GenericTypeClass a => a -> IO Bool
+genericType_is_double_vector x = casadi__GenericType__is_double_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_empty_vector" c_casadi__GenericType__is_empty_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_empty_vector
+  :: GenericType -> IO Bool
+casadi__GenericType__is_empty_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_empty_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_empty_vector :: GenericTypeClass a => a -> IO Bool
+genericType_is_empty_vector x = casadi__GenericType__is_empty_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_function" c_casadi__GenericType__is_function
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_function
+  :: GenericType -> IO Bool
+casadi__GenericType__is_function x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_function errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_function :: GenericTypeClass a => a -> IO Bool
+genericType_is_function x = casadi__GenericType__is_function (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_int" c_casadi__GenericType__is_int
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_int
+  :: GenericType -> IO Bool
+casadi__GenericType__is_int x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_int errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_int :: GenericTypeClass a => a -> IO Bool
+genericType_is_int x = casadi__GenericType__is_int (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_int_vector" c_casadi__GenericType__is_int_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_int_vector
+  :: GenericType -> IO Bool
+casadi__GenericType__is_int_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_int_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_int_vector :: GenericTypeClass a => a -> IO Bool
+genericType_is_int_vector x = casadi__GenericType__is_int_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_int_vector_vector" c_casadi__GenericType__is_int_vector_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_int_vector_vector
+  :: GenericType -> IO Bool
+casadi__GenericType__is_int_vector_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_int_vector_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_int_vector_vector :: GenericTypeClass a => a -> IO Bool
+genericType_is_int_vector_vector x = casadi__GenericType__is_int_vector_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_string" c_casadi__GenericType__is_string
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_string
+  :: GenericType -> IO Bool
+casadi__GenericType__is_string x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_string errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_string :: GenericTypeClass a => a -> IO Bool
+genericType_is_string x = casadi__GenericType__is_string (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_string_vector" c_casadi__GenericType__is_string_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_string_vector
+  :: GenericType -> IO Bool
+casadi__GenericType__is_string_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_string_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_string_vector :: GenericTypeClass a => a -> IO Bool
+genericType_is_string_vector x = casadi__GenericType__is_string_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__is_void_pointer" c_casadi__GenericType__is_void_pointer
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__is_void_pointer
+  :: GenericType -> IO Bool
+casadi__GenericType__is_void_pointer x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__is_void_pointer errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_is_void_pointer :: GenericTypeClass a => a -> IO Bool
+genericType_is_void_pointer x = casadi__GenericType__is_void_pointer (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__operator__nequals" c_casadi__GenericType__operator__nequals
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__operator__nequals
+  :: GenericType -> GenericType -> IO Bool
+casadi__GenericType__operator__nequals x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__operator__nequals errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_operator__nequals :: GenericTypeClass a => a -> GenericType -> IO Bool
+genericType_operator__nequals x = casadi__GenericType__operator__nequals (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__operator__equals" c_casadi__GenericType__operator__equals
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__operator__equals
+  :: GenericType -> GenericType -> IO Bool
+casadi__GenericType__operator__equals x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__operator__equals errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_operator__equals :: GenericTypeClass a => a -> GenericType -> IO Bool
+genericType_operator__equals x = casadi__GenericType__operator__equals (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_bool" c_casadi__GenericType__to_bool
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__to_bool
+  :: GenericType -> IO Bool
+casadi__GenericType__to_bool x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_bool errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_bool :: GenericTypeClass a => a -> IO Bool
+genericType_to_bool x = casadi__GenericType__to_bool (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_bool_vector" c_casadi__GenericType__to_bool_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec CInt))
+
+casadi__GenericType__to_bool_vector
+  :: GenericType -> IO (Vector Bool)
+casadi__GenericType__to_bool_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_bool_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_bool_vector :: GenericTypeClass a => a -> IO (Vector Bool)
+genericType_to_bool_vector x = casadi__GenericType__to_bool_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_dict" c_casadi__GenericType__to_dict
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdMap StdString (Ptr GenericType')))
+
+casadi__GenericType__to_dict
+  :: GenericType -> IO (M.Map String GenericType)
+casadi__GenericType__to_dict x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_dict errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_dict :: GenericTypeClass a => a -> IO (M.Map String GenericType)
+genericType_to_dict x = casadi__GenericType__to_dict (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_double" c_casadi__GenericType__to_double
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CDouble
+
+casadi__GenericType__to_double
+  :: GenericType -> IO Double
+casadi__GenericType__to_double x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_double errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_double :: GenericTypeClass a => a -> IO Double
+genericType_to_double x = casadi__GenericType__to_double (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_double_vector" c_casadi__GenericType__to_double_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec CDouble))
+
+casadi__GenericType__to_double_vector
+  :: GenericType -> IO (Vector Double)
+casadi__GenericType__to_double_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_double_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_double_vector :: GenericTypeClass a => a -> IO (Vector Double)
+genericType_to_double_vector x = casadi__GenericType__to_double_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_function" c_casadi__GenericType__to_function
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr Function')
+
+casadi__GenericType__to_function
+  :: GenericType -> IO Function
+casadi__GenericType__to_function x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_function errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_function :: GenericTypeClass a => a -> IO Function
+genericType_to_function x = casadi__GenericType__to_function (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_int" c_casadi__GenericType__to_int
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt
+
+casadi__GenericType__to_int
+  :: GenericType -> IO Int
+casadi__GenericType__to_int x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_int errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_int :: GenericTypeClass a => a -> IO Int
+genericType_to_int x = casadi__GenericType__to_int (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_int_vector" c_casadi__GenericType__to_int_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec CInt))
+
+casadi__GenericType__to_int_vector
+  :: GenericType -> IO (Vector Int)
+casadi__GenericType__to_int_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_int_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_int_vector :: GenericTypeClass a => a -> IO (Vector Int)
+genericType_to_int_vector x = casadi__GenericType__to_int_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_int_vector_vector" c_casadi__GenericType__to_int_vector_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec (Ptr (StdVec CInt))))
+
+casadi__GenericType__to_int_vector_vector
+  :: GenericType -> IO (Vector (Vector Int))
+casadi__GenericType__to_int_vector_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_int_vector_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_int_vector_vector :: GenericTypeClass a => a -> IO (Vector (Vector Int))
+genericType_to_int_vector_vector x = casadi__GenericType__to_int_vector_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_string" c_casadi__GenericType__to_string
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr StdString)
+
+casadi__GenericType__to_string
+  :: GenericType -> IO String
+casadi__GenericType__to_string x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_string errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_string :: GenericTypeClass a => a -> IO String
+genericType_to_string x = casadi__GenericType__to_string (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_string_vector" c_casadi__GenericType__to_string_vector
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdVec (Ptr StdString)))
+
+casadi__GenericType__to_string_vector
+  :: GenericType -> IO (Vector String)
+casadi__GenericType__to_string_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_string_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+genericType_to_string_vector :: GenericTypeClass a => a -> IO (Vector String)
+genericType_to_string_vector x = casadi__GenericType__to_string_vector (castGenericType x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GenericType__to_void_pointer" c_casadi__GenericType__to_void_pointer
+  :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO ()
+
+casadi__GenericType__to_void_pointer
+  :: GenericType -> IO ()
+casadi__GenericType__to_void_pointer x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GenericType__to_void_pointer errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+genericType_to_void_pointer :: GenericTypeClass a => a -> IO ()
+genericType_to_void_pointer x = casadi__GenericType__to_void_pointer (castGenericType x)
 
diff --git a/Casadi/Core/Classes/GlobalOptions.hs b/Casadi/Core/Classes/GlobalOptions.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/GlobalOptions.hs
@@ -0,0 +1,198 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.GlobalOptions
+       (
+         GlobalOptions,
+         GlobalOptionsClass(..),
+         globalOptions_getCasadiPath,
+         globalOptions_getHierarchicalSparsity,
+         globalOptions_getSimplificationOnTheFly,
+         globalOptions_setCasadiPath,
+         globalOptions_setHierarchicalSparsity,
+         globalOptions_setSimplificationOnTheFly,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__GlobalOptions__getCasadiPath" c_casadi__GlobalOptions__getCasadiPath
+  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
+casadi__GlobalOptions__getCasadiPath
+  :: IO String
+casadi__GlobalOptions__getCasadiPath  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GlobalOptions__getCasadiPath errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+globalOptions_getCasadiPath :: IO String
+globalOptions_getCasadiPath = casadi__GlobalOptions__getCasadiPath
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GlobalOptions__getHierarchicalSparsity" c_casadi__GlobalOptions__getHierarchicalSparsity
+  :: Ptr (Ptr StdString) -> IO CInt
+
+casadi__GlobalOptions__getHierarchicalSparsity
+  :: IO Bool
+casadi__GlobalOptions__getHierarchicalSparsity  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GlobalOptions__getHierarchicalSparsity errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+globalOptions_getHierarchicalSparsity :: IO Bool
+globalOptions_getHierarchicalSparsity = casadi__GlobalOptions__getHierarchicalSparsity
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GlobalOptions__getSimplificationOnTheFly" c_casadi__GlobalOptions__getSimplificationOnTheFly
+  :: Ptr (Ptr StdString) -> IO CInt
+
+casadi__GlobalOptions__getSimplificationOnTheFly
+  :: IO Bool
+casadi__GlobalOptions__getSimplificationOnTheFly  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GlobalOptions__getSimplificationOnTheFly errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+globalOptions_getSimplificationOnTheFly :: IO Bool
+globalOptions_getSimplificationOnTheFly = casadi__GlobalOptions__getSimplificationOnTheFly
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GlobalOptions__setCasadiPath" c_casadi__GlobalOptions__setCasadiPath
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
+casadi__GlobalOptions__setCasadiPath
+  :: String -> IO ()
+casadi__GlobalOptions__setCasadiPath x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GlobalOptions__setCasadiPath errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+globalOptions_setCasadiPath :: String -> IO ()
+globalOptions_setCasadiPath = casadi__GlobalOptions__setCasadiPath
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GlobalOptions__setHierarchicalSparsity" c_casadi__GlobalOptions__setHierarchicalSparsity
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__GlobalOptions__setHierarchicalSparsity
+  :: Bool -> IO ()
+casadi__GlobalOptions__setHierarchicalSparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GlobalOptions__setHierarchicalSparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+globalOptions_setHierarchicalSparsity :: Bool -> IO ()
+globalOptions_setHierarchicalSparsity = casadi__GlobalOptions__setHierarchicalSparsity
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__GlobalOptions__setSimplificationOnTheFly" c_casadi__GlobalOptions__setSimplificationOnTheFly
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__GlobalOptions__setSimplificationOnTheFly
+  :: Bool -> IO ()
+casadi__GlobalOptions__setSimplificationOnTheFly x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__GlobalOptions__setSimplificationOnTheFly errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+globalOptions_setSimplificationOnTheFly :: Bool -> IO ()
+globalOptions_setSimplificationOnTheFly = casadi__GlobalOptions__setSimplificationOnTheFly
+
diff --git a/Casadi/Core/Classes/HomotopyNlpSolver.hs b/Casadi/Core/Classes/HomotopyNlpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/HomotopyNlpSolver.hs
+++ /dev/null
@@ -1,114 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.HomotopyNlpSolver
-       (
-         HomotopyNlpSolver,
-         HomotopyNlpSolverClass(..),
-         homotopyNlpSolver,
-         homotopyNlpSolver_doc,
-         homotopyNlpSolver_hasPlugin,
-         homotopyNlpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__HomotopyNlpSolver__CONSTRUCTOR" c_casadi__HomotopyNlpSolver__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr HomotopyNlpSolver')
-casadi__HomotopyNlpSolver__CONSTRUCTOR
-  :: IO HomotopyNlpSolver
-casadi__HomotopyNlpSolver__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__HomotopyNlpSolver__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-homotopyNlpSolver :: IO HomotopyNlpSolver
-homotopyNlpSolver = casadi__HomotopyNlpSolver__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__HomotopyNlpSolver__doc" c_casadi__HomotopyNlpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__HomotopyNlpSolver__doc
-  :: String -> IO String
-casadi__HomotopyNlpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__HomotopyNlpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-homotopyNlpSolver_doc :: String -> IO String
-homotopyNlpSolver_doc = casadi__HomotopyNlpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__HomotopyNlpSolver__hasPlugin" c_casadi__HomotopyNlpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__HomotopyNlpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__HomotopyNlpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__HomotopyNlpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-homotopyNlpSolver_hasPlugin :: String -> IO Bool
-homotopyNlpSolver_hasPlugin = casadi__HomotopyNlpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__HomotopyNlpSolver__loadPlugin" c_casadi__HomotopyNlpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__HomotopyNlpSolver__loadPlugin
-  :: String -> IO ()
-casadi__HomotopyNlpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__HomotopyNlpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-homotopyNlpSolver_loadPlugin :: String -> IO ()
-homotopyNlpSolver_loadPlugin = casadi__HomotopyNlpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/IM.hs b/Casadi/Core/Classes/IM.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/IM.hs
@@ -0,0 +1,5732 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.IM
+       (
+         IM,
+         IMClass(..),
+         im_T,
+         im__0,
+         im__1,
+         im__10,
+         im__2,
+         im__3,
+         im__4,
+         im__5,
+         im__6,
+         im__7,
+         im__8,
+         im__9,
+         im___nonzero__,
+         im_binary,
+         im_clear,
+         im_colind,
+         im_dep__0,
+         im_dep__1,
+         im_dim,
+         im_element_hash,
+         im_enlarge__0,
+         im_enlarge__1,
+         im_erase__0,
+         im_erase__1,
+         im_erase__2,
+         im_erase__3,
+         im_eye,
+         im_getDescription,
+         im_getEqualityCheckingDepth,
+         im_getRepresentation,
+         im_get__0,
+         im_get__1,
+         im_get__2,
+         im_get__3,
+         im_get__4,
+         im_get__5,
+         im_get__6,
+         im_get_colind,
+         im_get_input,
+         im_get_nonzeros,
+         im_get_nz__0,
+         im_get_nz__1,
+         im_get_row,
+         im_get_sparsity,
+         im_grad__0,
+         im_grad__1,
+         im_grad__2,
+         im_grad__3,
+         im_grad__4,
+         im_grad__5,
+         im_grad__6,
+         im_has_duplicates,
+         im_has_nz,
+         im_has_zeros,
+         im_hess__0,
+         im_hess__1,
+         im_hess__2,
+         im_hess__3,
+         im_hess__4,
+         im_hess__5,
+         im_hess__6,
+         im_inf__0,
+         im_inf__1,
+         im_inf__2,
+         im_inf__3,
+         im_inf__4,
+         im_is_column,
+         im_is_commutative,
+         im_is_constant,
+         im_is_dense,
+         im_is_empty__0,
+         im_is_empty__1,
+         im_is_identity,
+         im_is_integer,
+         im_is_leaf,
+         im_is_minus_one,
+         im_is_one,
+         im_is_regular,
+         im_is_row,
+         im_is_scalar__0,
+         im_is_scalar__1,
+         im_is_smooth,
+         im_is_square,
+         im_is_symbolic,
+         im_is_tril,
+         im_is_triu,
+         im_is_valid_input,
+         im_is_vector,
+         im_is_zero,
+         im_jac__0,
+         im_jac__1,
+         im_jac__10,
+         im_jac__11,
+         im_jac__12,
+         im_jac__13,
+         im_jac__14,
+         im_jac__2,
+         im_jac__3,
+         im_jac__4,
+         im_jac__5,
+         im_jac__6,
+         im_jac__7,
+         im_jac__8,
+         im_jac__9,
+         im_matrix_matrix,
+         im_matrix_scalar,
+         im_n_dep,
+         im_name,
+         im_nan__0,
+         im_nan__1,
+         im_nan__2,
+         im_nan__3,
+         im_nan__4,
+         im_nnz,
+         im_nnz_diag,
+         im_nnz_lower,
+         im_nnz_upper,
+         im_numel__0,
+         im_numel__1,
+         im_ones__0,
+         im_ones__1,
+         im_ones__2,
+         im_ones__3,
+         im_ones__4,
+         im_operator__minus,
+         im_operator__plus,
+         im_operator_double,
+         im_operator_int,
+         im_print_dense,
+         im_print_scalar,
+         im_print_sparse,
+         im_print_split,
+         im_print_vector,
+         im_printme,
+         im_remove,
+         im_reserve__0,
+         im_reserve__1,
+         im_resetInput,
+         im_resize,
+         im_row,
+         im_sanity_check__0,
+         im_sanity_check__1,
+         im_scalar_matrix,
+         im_setEqualityCheckingDepth__0,
+         im_setEqualityCheckingDepth__1,
+         im_setPrecision,
+         im_setScientific,
+         im_setWidth,
+         im_set__0,
+         im_set__1,
+         im_set__2,
+         im_set__3,
+         im_set__4,
+         im_set__5,
+         im_set__6,
+         im_set_nz__0,
+         im_set_nz__1,
+         im_size1,
+         im_size2,
+         im_size__0,
+         im_size__1,
+         im_sparsity,
+         im_sym__0,
+         im_sym__1,
+         im_sym__2,
+         im_sym__3,
+         im_sym__4,
+         im_sym__5,
+         im_sym__6,
+         im_sym__7,
+         im_sym__8,
+         im_tang__0,
+         im_tang__1,
+         im_tang__2,
+         im_tang__3,
+         im_tang__4,
+         im_tang__5,
+         im_tang__6,
+         im_triplet__0,
+         im_triplet__1,
+         im_triplet__2,
+         im_type_name,
+         im_unary,
+         im_zeros__0,
+         im_zeros__1,
+         im_zeros__2,
+         im_zeros__3,
+         im_zeros__4,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__0" c_casadi__IM__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SXElem')) -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__0
+  :: Vector SXElem -> IO IM
+casadi__IM__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__0 :: Vector SXElem -> IO IM
+im__0 = casadi__IM__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__1" c_casadi__IM__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__1
+  :: SX -> IO IM
+casadi__IM__CONSTRUCTOR__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__1 :: SX -> IO IM
+im__1 = casadi__IM__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__2" c_casadi__IM__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__2
+  :: Vector Double -> IO IM
+casadi__IM__CONSTRUCTOR__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__2 :: Vector Double -> IO IM
+im__2 = casadi__IM__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__3" c_casadi__IM__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__3
+  :: DM -> IO IM
+casadi__IM__CONSTRUCTOR__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__3 :: DM -> IO IM
+im__3 = casadi__IM__CONSTRUCTOR__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__4" c_casadi__IM__CONSTRUCTOR__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__4
+  :: Vector (Vector Double) -> IO IM
+casadi__IM__CONSTRUCTOR__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__4 :: Vector (Vector Double) -> IO IM
+im__4 = casadi__IM__CONSTRUCTOR__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__5" c_casadi__IM__CONSTRUCTOR__5
+  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__5
+  :: Double -> IO IM
+casadi__IM__CONSTRUCTOR__5 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__5 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__5 :: Double -> IO IM
+im__5 = casadi__IM__CONSTRUCTOR__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__6" c_casadi__IM__CONSTRUCTOR__6
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__6
+  :: Sparsity -> IM -> IO IM
+casadi__IM__CONSTRUCTOR__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im__6 :: Sparsity -> IM -> IO IM
+im__6 = casadi__IM__CONSTRUCTOR__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__7" c_casadi__IM__CONSTRUCTOR__7
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__7
+  :: Sparsity -> IO IM
+casadi__IM__CONSTRUCTOR__7 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__7 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__7 :: Sparsity -> IO IM
+im__7 = casadi__IM__CONSTRUCTOR__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__8" c_casadi__IM__CONSTRUCTOR__8
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__8
+  :: Int -> Int -> IO IM
+casadi__IM__CONSTRUCTOR__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im__8 :: Int -> Int -> IO IM
+im__8 = casadi__IM__CONSTRUCTOR__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__9" c_casadi__IM__CONSTRUCTOR__9
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__9
+  :: IM -> IO IM
+casadi__IM__CONSTRUCTOR__9 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__9 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im__9 :: IM -> IO IM
+im__9 = casadi__IM__CONSTRUCTOR__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__CONSTRUCTOR__10" c_casadi__IM__CONSTRUCTOR__10
+  :: Ptr (Ptr StdString) -> IO (Ptr IM')
+
+casadi__IM__CONSTRUCTOR__10
+  :: IO IM
+casadi__IM__CONSTRUCTOR__10  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__CONSTRUCTOR__10 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+im__10 :: IO IM
+im__10 = casadi__IM__CONSTRUCTOR__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__T" c_casadi__IM__T
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__T
+  :: IM -> IO IM
+casadi__IM__T x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__T errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_T :: IMClass a => a -> IO IM
+im_T x = casadi__IM__T (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM____nonzero__" c_casadi__IM____nonzero__
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM____nonzero__
+  :: IM -> IO Bool
+casadi__IM____nonzero__ x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM____nonzero__ errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im___nonzero__ :: IMClass a => a -> IO Bool
+im___nonzero__ x = casadi__IM____nonzero__ (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__binary" c_casadi__IM__binary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__binary
+  :: Int -> IM -> IM -> IO IM
+casadi__IM__binary x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__binary errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_binary :: Int -> IM -> IM -> IO IM
+im_binary = casadi__IM__binary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__clear" c_casadi__IM__clear
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO ()
+
+casadi__IM__clear
+  :: IM -> IO ()
+casadi__IM__clear x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__clear errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_clear :: IMClass a => a -> IO ()
+im_clear x = casadi__IM__clear (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__colind" c_casadi__IM__colind
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO CInt
+
+casadi__IM__colind
+  :: IM -> Int -> IO Int
+casadi__IM__colind x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__colind errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_colind :: IMClass a => a -> Int -> IO Int
+im_colind x = casadi__IM__colind (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__dep__0" c_casadi__IM__dep__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__dep__0
+  :: IM -> IO IM
+casadi__IM__dep__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__dep__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_dep__0 :: IMClass a => a -> IO IM
+im_dep__0 x = casadi__IM__dep__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__dep__1" c_casadi__IM__dep__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi__IM__dep__1
+  :: IM -> Int -> IO IM
+casadi__IM__dep__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__dep__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_dep__1 :: IMClass a => a -> Int -> IO IM
+im_dep__1 x = casadi__IM__dep__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__dim" c_casadi__IM__dim
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr StdString)
+
+casadi__IM__dim
+  :: IM -> IO String
+casadi__IM__dim x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__dim errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_dim :: IMClass a => a -> IO String
+im_dim x = casadi__IM__dim (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__element_hash" c_casadi__IM__element_hash
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CSize
+
+casadi__IM__element_hash
+  :: IM -> IO CSize
+casadi__IM__element_hash x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__element_hash errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_element_hash :: IMClass a => a -> IO CSize
+im_element_hash x = casadi__IM__element_hash (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__enlarge__0" c_casadi__IM__enlarge__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__IM__enlarge__0
+  :: IM -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+casadi__IM__enlarge__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+im_enlarge__0 :: IMClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+im_enlarge__0 x = casadi__IM__enlarge__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__enlarge__1" c_casadi__IM__enlarge__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__IM__enlarge__1
+  :: IM -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__IM__enlarge__1 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+-- classy wrapper
+im_enlarge__1 :: IMClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+im_enlarge__1 x = casadi__IM__enlarge__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__erase__0" c_casadi__IM__erase__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> IO ()
+
+casadi__IM__erase__0
+  :: IM -> Vector Int -> IO ()
+casadi__IM__erase__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__erase__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+im_erase__0 :: IMClass a => a -> Vector Int -> IO ()
+im_erase__0 x = casadi__IM__erase__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__erase__1" c_casadi__IM__erase__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__IM__erase__1
+  :: IM -> Vector Int -> Bool -> IO ()
+casadi__IM__erase__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__erase__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+im_erase__1 :: IMClass a => a -> Vector Int -> Bool -> IO ()
+im_erase__1 x = casadi__IM__erase__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__erase__2" c_casadi__IM__erase__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__IM__erase__2
+  :: IM -> Vector Int -> Vector Int -> IO ()
+casadi__IM__erase__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__erase__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+im_erase__2 :: IMClass a => a -> Vector Int -> Vector Int -> IO ()
+im_erase__2 x = casadi__IM__erase__2 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__erase__3" c_casadi__IM__erase__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__IM__erase__3
+  :: IM -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__IM__erase__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__erase__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+im_erase__3 :: IMClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
+im_erase__3 x = casadi__IM__erase__3 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__eye" c_casadi__IM__eye
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IM')
+
+casadi__IM__eye
+  :: Int -> IO IM
+casadi__IM__eye x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__eye errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_eye :: Int -> IO IM
+im_eye = casadi__IM__eye
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get__0" c_casadi__IM__get__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__IM__get__0
+  :: IM -> Bool -> IM -> IM -> IO (IM)
+casadi__IM__get__0 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get__0 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get__0/c_casadi__IM__get__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get__0 :: IMClass a => a -> Bool -> IM -> IM -> IO (IM)
+im_get__0 x = casadi__IM__get__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get__1" c_casadi__IM__get__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__IM__get__1
+  :: IM -> Bool -> IM -> Slice -> IO (IM)
+casadi__IM__get__1 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get__1 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get__1/c_casadi__IM__get__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get__1 :: IMClass a => a -> Bool -> IM -> Slice -> IO (IM)
+im_get__1 x = casadi__IM__get__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get__2" c_casadi__IM__get__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__IM__get__2
+  :: IM -> Bool -> Slice -> IM -> IO (IM)
+casadi__IM__get__2 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get__2 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get__2/c_casadi__IM__get__2" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get__2 :: IMClass a => a -> Bool -> Slice -> IM -> IO (IM)
+im_get__2 x = casadi__IM__get__2 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get__3" c_casadi__IM__get__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__IM__get__3
+  :: IM -> Bool -> Slice -> Slice -> IO (IM)
+casadi__IM__get__3 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get__3 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get__3/c_casadi__IM__get__3" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get__3 :: IMClass a => a -> Bool -> Slice -> Slice -> IO (IM)
+im_get__3 x = casadi__IM__get__3 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get__4" c_casadi__IM__get__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__IM__get__4
+  :: IM -> Bool -> Sparsity -> IO (IM)
+casadi__IM__get__4 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get__4 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get__4/c_casadi__IM__get__4" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get__4 :: IMClass a => a -> Bool -> Sparsity -> IO (IM)
+im_get__4 x = casadi__IM__get__4 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get__5" c_casadi__IM__get__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr IM' -> IO ()
+
+casadi__IM__get__5
+  :: IM -> Bool -> IM -> IO (IM)
+casadi__IM__get__5 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get__5 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get__5/c_casadi__IM__get__5" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get__5 :: IMClass a => a -> Bool -> IM -> IO (IM)
+im_get__5 x = casadi__IM__get__5 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get__6" c_casadi__IM__get__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__IM__get__6
+  :: IM -> Bool -> Slice -> IO (IM)
+casadi__IM__get__6 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get__6 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get__6/c_casadi__IM__get__6" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get__6 :: IMClass a => a -> Bool -> Slice -> IO (IM)
+im_get__6 x = casadi__IM__get__6 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__getEqualityCheckingDepth" c_casadi__IM__getEqualityCheckingDepth
+  :: Ptr (Ptr StdString) -> IO CInt
+
+casadi__IM__getEqualityCheckingDepth
+  :: IO Int
+casadi__IM__getEqualityCheckingDepth  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__getEqualityCheckingDepth errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+im_getEqualityCheckingDepth :: IO Int
+im_getEqualityCheckingDepth = casadi__IM__getEqualityCheckingDepth
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get_colind" c_casadi__IM__get_colind
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec CInt))
+
+casadi__IM__get_colind
+  :: IM -> IO (Vector Int)
+casadi__IM__get_colind x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get_colind errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_get_colind :: IMClass a => a -> IO (Vector Int)
+im_get_colind x = casadi__IM__get_colind (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get_input" c_casadi__IM__get_input
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi__IM__get_input
+  :: Function -> IO (Vector IM)
+casadi__IM__get_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_get_input :: Function -> IO (Vector IM)
+im_get_input = casadi__IM__get_input
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get_nonzeros" c_casadi__IM__get_nonzeros
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec CInt))
+
+casadi__IM__get_nonzeros
+  :: IM -> IO (Vector Int)
+casadi__IM__get_nonzeros x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get_nonzeros errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_get_nonzeros :: IMClass a => a -> IO (Vector Int)
+im_get_nonzeros x = casadi__IM__get_nonzeros (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get_nz__0" c_casadi__IM__get_nz__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr IM' -> IO ()
+
+casadi__IM__get_nz__0
+  :: IM -> Bool -> IM -> IO (IM)
+casadi__IM__get_nz__0 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get_nz__0 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get_nz__0/c_casadi__IM__get_nz__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get_nz__0 :: IMClass a => a -> Bool -> IM -> IO (IM)
+im_get_nz__0 x = casadi__IM__get_nz__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get_nz__1" c_casadi__IM__get_nz__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr IM') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__IM__get_nz__1
+  :: IM -> Bool -> Slice -> IO (IM)
+casadi__IM__get_nz__1 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get_nz__1 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__get_nz__1/c_casadi__IM__get_nz__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+im_get_nz__1 :: IMClass a => a -> Bool -> Slice -> IO (IM)
+im_get_nz__1 x = casadi__IM__get_nz__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get_row" c_casadi__IM__get_row
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec CInt))
+
+casadi__IM__get_row
+  :: IM -> IO (Vector Int)
+casadi__IM__get_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_get_row :: IMClass a => a -> IO (Vector Int)
+im_get_row x = casadi__IM__get_row (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__get_sparsity" c_casadi__IM__get_sparsity
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr Sparsity')
+
+casadi__IM__get_sparsity
+  :: IM -> IO Sparsity
+casadi__IM__get_sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__get_sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_get_sparsity :: IMClass a => a -> IO Sparsity
+im_get_sparsity x = casadi__IM__get_sparsity (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__grad__0" c_casadi__IM__grad__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__grad__0
+  :: Function -> String -> String -> IO IM
+casadi__IM__grad__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__grad__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_grad__0 :: Function -> String -> String -> IO IM
+im_grad__0 = casadi__IM__grad__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__grad__1" c_casadi__IM__grad__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__grad__1
+  :: Function -> Int -> String -> IO IM
+casadi__IM__grad__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__grad__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_grad__1 :: Function -> Int -> String -> IO IM
+im_grad__1 = casadi__IM__grad__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__grad__2" c_casadi__IM__grad__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__grad__2
+  :: Function -> String -> IO IM
+casadi__IM__grad__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__grad__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_grad__2 :: Function -> String -> IO IM
+im_grad__2 = casadi__IM__grad__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__grad__3" c_casadi__IM__grad__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr IM')
+
+casadi__IM__grad__3
+  :: Function -> String -> Int -> IO IM
+casadi__IM__grad__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__grad__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_grad__3 :: Function -> String -> Int -> IO IM
+im_grad__3 = casadi__IM__grad__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__grad__4" c_casadi__IM__grad__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IM')
+
+casadi__IM__grad__4
+  :: Function -> IO IM
+casadi__IM__grad__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__grad__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_grad__4 :: Function -> IO IM
+im_grad__4 = casadi__IM__grad__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__grad__5" c_casadi__IM__grad__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr IM')
+
+casadi__IM__grad__5
+  :: Function -> Int -> IO IM
+casadi__IM__grad__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__grad__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_grad__5 :: Function -> Int -> IO IM
+im_grad__5 = casadi__IM__grad__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__grad__6" c_casadi__IM__grad__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__grad__6
+  :: Function -> Int -> Int -> IO IM
+casadi__IM__grad__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__grad__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_grad__6 :: Function -> Int -> Int -> IO IM
+im_grad__6 = casadi__IM__grad__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__has_duplicates" c_casadi__IM__has_duplicates
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__has_duplicates
+  :: IM -> IO Bool
+casadi__IM__has_duplicates x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__has_duplicates errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_has_duplicates :: IMClass a => a -> IO Bool
+im_has_duplicates x = casadi__IM__has_duplicates (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__has_nz" c_casadi__IM__has_nz
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO CInt
+
+casadi__IM__has_nz
+  :: IM -> Int -> Int -> IO Bool
+casadi__IM__has_nz x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__has_nz errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_has_nz :: IMClass a => a -> Int -> Int -> IO Bool
+im_has_nz x = casadi__IM__has_nz (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__has_zeros" c_casadi__IM__has_zeros
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__has_zeros
+  :: IM -> IO Bool
+casadi__IM__has_zeros x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__has_zeros errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_has_zeros :: IMClass a => a -> IO Bool
+im_has_zeros x = casadi__IM__has_zeros (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__hess__0" c_casadi__IM__hess__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__hess__0
+  :: Function -> String -> String -> IO IM
+casadi__IM__hess__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__hess__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_hess__0 :: Function -> String -> String -> IO IM
+im_hess__0 = casadi__IM__hess__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__hess__1" c_casadi__IM__hess__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__hess__1
+  :: Function -> Int -> String -> IO IM
+casadi__IM__hess__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__hess__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_hess__1 :: Function -> Int -> String -> IO IM
+im_hess__1 = casadi__IM__hess__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__hess__2" c_casadi__IM__hess__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__hess__2
+  :: Function -> String -> IO IM
+casadi__IM__hess__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__hess__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_hess__2 :: Function -> String -> IO IM
+im_hess__2 = casadi__IM__hess__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__hess__3" c_casadi__IM__hess__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr IM')
+
+casadi__IM__hess__3
+  :: Function -> String -> Int -> IO IM
+casadi__IM__hess__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__hess__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_hess__3 :: Function -> String -> Int -> IO IM
+im_hess__3 = casadi__IM__hess__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__hess__4" c_casadi__IM__hess__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IM')
+
+casadi__IM__hess__4
+  :: Function -> IO IM
+casadi__IM__hess__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__hess__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_hess__4 :: Function -> IO IM
+im_hess__4 = casadi__IM__hess__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__hess__5" c_casadi__IM__hess__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr IM')
+
+casadi__IM__hess__5
+  :: Function -> Int -> IO IM
+casadi__IM__hess__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__hess__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_hess__5 :: Function -> Int -> IO IM
+im_hess__5 = casadi__IM__hess__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__hess__6" c_casadi__IM__hess__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__hess__6
+  :: Function -> Int -> Int -> IO IM
+casadi__IM__hess__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__hess__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_hess__6 :: Function -> Int -> Int -> IO IM
+im_hess__6 = casadi__IM__hess__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__inf__0" c_casadi__IM__inf__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi__IM__inf__0
+  :: (Int, Int) -> IO IM
+casadi__IM__inf__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__inf__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_inf__0 :: (Int, Int) -> IO IM
+im_inf__0 = casadi__IM__inf__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__inf__1" c_casadi__IM__inf__1
+  :: Ptr (Ptr StdString) -> IO (Ptr IM')
+
+casadi__IM__inf__1
+  :: IO IM
+casadi__IM__inf__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__inf__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+im_inf__1 :: IO IM
+im_inf__1 = casadi__IM__inf__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__inf__2" c_casadi__IM__inf__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IM')
+
+casadi__IM__inf__2
+  :: Int -> IO IM
+casadi__IM__inf__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__inf__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_inf__2 :: Int -> IO IM
+im_inf__2 = casadi__IM__inf__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__inf__3" c_casadi__IM__inf__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__inf__3
+  :: Int -> Int -> IO IM
+casadi__IM__inf__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__inf__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_inf__3 :: Int -> Int -> IO IM
+im_inf__3 = casadi__IM__inf__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__inf__4" c_casadi__IM__inf__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi__IM__inf__4
+  :: Sparsity -> IO IM
+casadi__IM__inf__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__inf__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_inf__4 :: Sparsity -> IO IM
+im_inf__4 = casadi__IM__inf__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_column" c_casadi__IM__is_column
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_column
+  :: IM -> IO Bool
+casadi__IM__is_column x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_column errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_column :: IMClass a => a -> IO Bool
+im_is_column x = casadi__IM__is_column (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_commutative" c_casadi__IM__is_commutative
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_commutative
+  :: IM -> IO Bool
+casadi__IM__is_commutative x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_commutative errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_commutative :: IMClass a => a -> IO Bool
+im_is_commutative x = casadi__IM__is_commutative (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_constant" c_casadi__IM__is_constant
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_constant
+  :: IM -> IO Bool
+casadi__IM__is_constant x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_constant errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_constant :: IMClass a => a -> IO Bool
+im_is_constant x = casadi__IM__is_constant (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_dense" c_casadi__IM__is_dense
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_dense
+  :: IM -> IO Bool
+casadi__IM__is_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_dense :: IMClass a => a -> IO Bool
+im_is_dense x = casadi__IM__is_dense (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_empty__0" c_casadi__IM__is_empty__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_empty__0
+  :: IM -> IO Bool
+casadi__IM__is_empty__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_empty__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_empty__0 :: IMClass a => a -> IO Bool
+im_is_empty__0 x = casadi__IM__is_empty__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_empty__1" c_casadi__IM__is_empty__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO CInt
+
+casadi__IM__is_empty__1
+  :: IM -> Bool -> IO Bool
+casadi__IM__is_empty__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_empty__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_empty__1 :: IMClass a => a -> Bool -> IO Bool
+im_is_empty__1 x = casadi__IM__is_empty__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_identity" c_casadi__IM__is_identity
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_identity
+  :: IM -> IO Bool
+casadi__IM__is_identity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_identity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_identity :: IMClass a => a -> IO Bool
+im_is_identity x = casadi__IM__is_identity (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_integer" c_casadi__IM__is_integer
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_integer
+  :: IM -> IO Bool
+casadi__IM__is_integer x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_integer errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_integer :: IMClass a => a -> IO Bool
+im_is_integer x = casadi__IM__is_integer (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_leaf" c_casadi__IM__is_leaf
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_leaf
+  :: IM -> IO Bool
+casadi__IM__is_leaf x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_leaf errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_leaf :: IMClass a => a -> IO Bool
+im_is_leaf x = casadi__IM__is_leaf (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_minus_one" c_casadi__IM__is_minus_one
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_minus_one
+  :: IM -> IO Bool
+casadi__IM__is_minus_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_minus_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_minus_one :: IMClass a => a -> IO Bool
+im_is_minus_one x = casadi__IM__is_minus_one (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_one" c_casadi__IM__is_one
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_one
+  :: IM -> IO Bool
+casadi__IM__is_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_one :: IMClass a => a -> IO Bool
+im_is_one x = casadi__IM__is_one (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_regular" c_casadi__IM__is_regular
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_regular
+  :: IM -> IO Bool
+casadi__IM__is_regular x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_regular errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_regular :: IMClass a => a -> IO Bool
+im_is_regular x = casadi__IM__is_regular (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_row" c_casadi__IM__is_row
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_row
+  :: IM -> IO Bool
+casadi__IM__is_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_row :: IMClass a => a -> IO Bool
+im_is_row x = casadi__IM__is_row (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_scalar__0" c_casadi__IM__is_scalar__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_scalar__0
+  :: IM -> IO Bool
+casadi__IM__is_scalar__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_scalar__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_scalar__0 :: IMClass a => a -> IO Bool
+im_is_scalar__0 x = casadi__IM__is_scalar__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_scalar__1" c_casadi__IM__is_scalar__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO CInt
+
+casadi__IM__is_scalar__1
+  :: IM -> Bool -> IO Bool
+casadi__IM__is_scalar__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_scalar__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_scalar__1 :: IMClass a => a -> Bool -> IO Bool
+im_is_scalar__1 x = casadi__IM__is_scalar__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_smooth" c_casadi__IM__is_smooth
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_smooth
+  :: IM -> IO Bool
+casadi__IM__is_smooth x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_smooth errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_smooth :: IMClass a => a -> IO Bool
+im_is_smooth x = casadi__IM__is_smooth (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_square" c_casadi__IM__is_square
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_square
+  :: IM -> IO Bool
+casadi__IM__is_square x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_square errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_square :: IMClass a => a -> IO Bool
+im_is_square x = casadi__IM__is_square (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_symbolic" c_casadi__IM__is_symbolic
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_symbolic
+  :: IM -> IO Bool
+casadi__IM__is_symbolic x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_symbolic errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_symbolic :: IMClass a => a -> IO Bool
+im_is_symbolic x = casadi__IM__is_symbolic (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_tril" c_casadi__IM__is_tril
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_tril
+  :: IM -> IO Bool
+casadi__IM__is_tril x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_tril errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_tril :: IMClass a => a -> IO Bool
+im_is_tril x = casadi__IM__is_tril (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_triu" c_casadi__IM__is_triu
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_triu
+  :: IM -> IO Bool
+casadi__IM__is_triu x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_triu errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_triu :: IMClass a => a -> IO Bool
+im_is_triu x = casadi__IM__is_triu (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_valid_input" c_casadi__IM__is_valid_input
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_valid_input
+  :: IM -> IO Bool
+casadi__IM__is_valid_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_valid_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_valid_input :: IMClass a => a -> IO Bool
+im_is_valid_input x = casadi__IM__is_valid_input (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_vector" c_casadi__IM__is_vector
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_vector
+  :: IM -> IO Bool
+casadi__IM__is_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_vector :: IMClass a => a -> IO Bool
+im_is_vector x = casadi__IM__is_vector (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__is_zero" c_casadi__IM__is_zero
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__is_zero
+  :: IM -> IO Bool
+casadi__IM__is_zero x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__is_zero errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_is_zero :: IMClass a => a -> IO Bool
+im_is_zero x = casadi__IM__is_zero (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__0" c_casadi__IM__jac__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__jac__0
+  :: Function -> String -> String -> IO IM
+casadi__IM__jac__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__0 :: Function -> String -> String -> IO IM
+im_jac__0 = casadi__IM__jac__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__1" c_casadi__IM__jac__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__1
+  :: Function -> String -> String -> Bool -> IO IM
+casadi__IM__jac__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__1 :: Function -> String -> String -> Bool -> IO IM
+im_jac__1 = casadi__IM__jac__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__2" c_casadi__IM__jac__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__2
+  :: Function -> String -> String -> Bool -> Bool -> IO IM
+casadi__IM__jac__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__2 :: Function -> String -> String -> Bool -> Bool -> IO IM
+im_jac__2 = casadi__IM__jac__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__3" c_casadi__IM__jac__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__jac__3
+  :: Function -> Int -> String -> IO IM
+casadi__IM__jac__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__3 :: Function -> Int -> String -> IO IM
+im_jac__3 = casadi__IM__jac__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__4" c_casadi__IM__jac__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__4
+  :: Function -> Int -> String -> Bool -> IO IM
+casadi__IM__jac__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__4 :: Function -> Int -> String -> Bool -> IO IM
+im_jac__4 = casadi__IM__jac__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__5" c_casadi__IM__jac__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__5
+  :: Function -> Int -> String -> Bool -> Bool -> IO IM
+casadi__IM__jac__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__5 :: Function -> Int -> String -> Bool -> Bool -> IO IM
+im_jac__5 = casadi__IM__jac__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__6" c_casadi__IM__jac__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__jac__6
+  :: Function -> String -> IO IM
+casadi__IM__jac__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__6 :: Function -> String -> IO IM
+im_jac__6 = casadi__IM__jac__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__7" c_casadi__IM__jac__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__7
+  :: Function -> String -> Int -> IO IM
+casadi__IM__jac__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__7 :: Function -> String -> Int -> IO IM
+im_jac__7 = casadi__IM__jac__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__8" c_casadi__IM__jac__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__8
+  :: Function -> String -> Int -> Bool -> IO IM
+casadi__IM__jac__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__8 :: Function -> String -> Int -> Bool -> IO IM
+im_jac__8 = casadi__IM__jac__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__9" c_casadi__IM__jac__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__9
+  :: Function -> String -> Int -> Bool -> Bool -> IO IM
+casadi__IM__jac__9 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__9 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__9 :: Function -> String -> Int -> Bool -> Bool -> IO IM
+im_jac__9 = casadi__IM__jac__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__10" c_casadi__IM__jac__10
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IM')
+
+casadi__IM__jac__10
+  :: Function -> IO IM
+casadi__IM__jac__10 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__10 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__10 :: Function -> IO IM
+im_jac__10 = casadi__IM__jac__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__11" c_casadi__IM__jac__11
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__11
+  :: Function -> Int -> IO IM
+casadi__IM__jac__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__11 :: Function -> Int -> IO IM
+im_jac__11 = casadi__IM__jac__11
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__12" c_casadi__IM__jac__12
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__12
+  :: Function -> Int -> Int -> IO IM
+casadi__IM__jac__12 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__12 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__12 :: Function -> Int -> Int -> IO IM
+im_jac__12 = casadi__IM__jac__12
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__13" c_casadi__IM__jac__13
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__13
+  :: Function -> Int -> Int -> Bool -> IO IM
+casadi__IM__jac__13 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__13 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__13 :: Function -> Int -> Int -> Bool -> IO IM
+im_jac__13 = casadi__IM__jac__13
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__jac__14" c_casadi__IM__jac__14
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__jac__14
+  :: Function -> Int -> Int -> Bool -> Bool -> IO IM
+casadi__IM__jac__14 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__jac__14 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+im_jac__14 :: Function -> Int -> Int -> Bool -> Bool -> IO IM
+im_jac__14 = casadi__IM__jac__14
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__matrix_matrix" c_casadi__IM__matrix_matrix
+  :: Ptr (Ptr StdString) -> CInt -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__matrix_matrix
+  :: Int -> IM -> IM -> IO IM
+casadi__IM__matrix_matrix x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__matrix_matrix errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_matrix_matrix :: Int -> IM -> IM -> IO IM
+im_matrix_matrix = casadi__IM__matrix_matrix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__matrix_scalar" c_casadi__IM__matrix_scalar
+  :: Ptr (Ptr StdString) -> CInt -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__matrix_scalar
+  :: Int -> IM -> IM -> IO IM
+casadi__IM__matrix_scalar x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__matrix_scalar errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_matrix_scalar :: Int -> IM -> IM -> IO IM
+im_matrix_scalar = casadi__IM__matrix_scalar
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__n_dep" c_casadi__IM__n_dep
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__n_dep
+  :: IM -> IO Int
+casadi__IM__n_dep x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__n_dep errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_n_dep :: IMClass a => a -> IO Int
+im_n_dep x = casadi__IM__n_dep (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__name" c_casadi__IM__name
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr StdString)
+
+casadi__IM__name
+  :: IM -> IO String
+casadi__IM__name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_name :: IMClass a => a -> IO String
+im_name x = casadi__IM__name (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nan__0" c_casadi__IM__nan__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi__IM__nan__0
+  :: (Int, Int) -> IO IM
+casadi__IM__nan__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nan__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nan__0 :: (Int, Int) -> IO IM
+im_nan__0 = casadi__IM__nan__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nan__1" c_casadi__IM__nan__1
+  :: Ptr (Ptr StdString) -> IO (Ptr IM')
+
+casadi__IM__nan__1
+  :: IO IM
+casadi__IM__nan__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nan__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+im_nan__1 :: IO IM
+im_nan__1 = casadi__IM__nan__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nan__2" c_casadi__IM__nan__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IM')
+
+casadi__IM__nan__2
+  :: Int -> IO IM
+casadi__IM__nan__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nan__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nan__2 :: Int -> IO IM
+im_nan__2 = casadi__IM__nan__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nan__3" c_casadi__IM__nan__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__nan__3
+  :: Int -> Int -> IO IM
+casadi__IM__nan__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nan__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nan__3 :: Int -> Int -> IO IM
+im_nan__3 = casadi__IM__nan__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nan__4" c_casadi__IM__nan__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi__IM__nan__4
+  :: Sparsity -> IO IM
+casadi__IM__nan__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nan__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nan__4 :: Sparsity -> IO IM
+im_nan__4 = casadi__IM__nan__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nnz" c_casadi__IM__nnz
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__nnz
+  :: IM -> IO Int
+casadi__IM__nnz x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nnz errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nnz :: IMClass a => a -> IO Int
+im_nnz x = casadi__IM__nnz (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nnz_diag" c_casadi__IM__nnz_diag
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__nnz_diag
+  :: IM -> IO Int
+casadi__IM__nnz_diag x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nnz_diag errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nnz_diag :: IMClass a => a -> IO Int
+im_nnz_diag x = casadi__IM__nnz_diag (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nnz_lower" c_casadi__IM__nnz_lower
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__nnz_lower
+  :: IM -> IO Int
+casadi__IM__nnz_lower x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nnz_lower errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nnz_lower :: IMClass a => a -> IO Int
+im_nnz_lower x = casadi__IM__nnz_lower (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__nnz_upper" c_casadi__IM__nnz_upper
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__nnz_upper
+  :: IM -> IO Int
+casadi__IM__nnz_upper x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__nnz_upper errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_nnz_upper :: IMClass a => a -> IO Int
+im_nnz_upper x = casadi__IM__nnz_upper (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__numel__0" c_casadi__IM__numel__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO CInt
+
+casadi__IM__numel__0
+  :: IM -> Int -> IO Int
+casadi__IM__numel__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__numel__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_numel__0 :: IMClass a => a -> Int -> IO Int
+im_numel__0 x = casadi__IM__numel__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__numel__1" c_casadi__IM__numel__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__numel__1
+  :: IM -> IO Int
+casadi__IM__numel__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__numel__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_numel__1 :: IMClass a => a -> IO Int
+im_numel__1 x = casadi__IM__numel__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__ones__0" c_casadi__IM__ones__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi__IM__ones__0
+  :: (Int, Int) -> IO IM
+casadi__IM__ones__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__ones__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_ones__0 :: (Int, Int) -> IO IM
+im_ones__0 = casadi__IM__ones__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__ones__1" c_casadi__IM__ones__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi__IM__ones__1
+  :: Sparsity -> IO IM
+casadi__IM__ones__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__ones__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_ones__1 :: Sparsity -> IO IM
+im_ones__1 = casadi__IM__ones__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__ones__2" c_casadi__IM__ones__2
+  :: Ptr (Ptr StdString) -> IO (Ptr IM')
+
+casadi__IM__ones__2
+  :: IO IM
+casadi__IM__ones__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__ones__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+im_ones__2 :: IO IM
+im_ones__2 = casadi__IM__ones__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__ones__3" c_casadi__IM__ones__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IM')
+
+casadi__IM__ones__3
+  :: Int -> IO IM
+casadi__IM__ones__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__ones__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_ones__3 :: Int -> IO IM
+im_ones__3 = casadi__IM__ones__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__ones__4" c_casadi__IM__ones__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__ones__4
+  :: Int -> Int -> IO IM
+casadi__IM__ones__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__ones__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_ones__4 :: Int -> Int -> IO IM
+im_ones__4 = casadi__IM__ones__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__operator__plus" c_casadi__IM__operator__plus
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__operator__plus
+  :: IM -> IO IM
+casadi__IM__operator__plus x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__operator__plus errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_operator__plus :: IMClass a => a -> IO IM
+im_operator__plus x = casadi__IM__operator__plus (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__operator__minus" c_casadi__IM__operator__minus
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__operator__minus
+  :: IM -> IO IM
+casadi__IM__operator__minus x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__operator__minus errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_operator__minus :: IMClass a => a -> IO IM
+im_operator__minus x = casadi__IM__operator__minus (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__operator_double" c_casadi__IM__operator_double
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CDouble
+
+casadi__IM__operator_double
+  :: IM -> IO Double
+casadi__IM__operator_double x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__operator_double errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_operator_double :: IMClass a => a -> IO Double
+im_operator_double x = casadi__IM__operator_double (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__operator_int" c_casadi__IM__operator_int
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__operator_int
+  :: IM -> IO Int
+casadi__IM__operator_int x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__operator_int errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_operator_int :: IMClass a => a -> IO Int
+im_operator_int x = casadi__IM__operator_int (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__print_dense" c_casadi__IM__print_dense
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO ()
+
+casadi__IM__print_dense
+  :: IM -> IO ()
+casadi__IM__print_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__print_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_print_dense :: IMClass a => a -> IO ()
+im_print_dense x = casadi__IM__print_dense (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__print_scalar" c_casadi__IM__print_scalar
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO ()
+
+casadi__IM__print_scalar
+  :: IM -> IO ()
+casadi__IM__print_scalar x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__print_scalar errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_print_scalar :: IMClass a => a -> IO ()
+im_print_scalar x = casadi__IM__print_scalar (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__print_sparse" c_casadi__IM__print_sparse
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO ()
+
+casadi__IM__print_sparse
+  :: IM -> IO ()
+casadi__IM__print_sparse x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__print_sparse errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_print_sparse :: IMClass a => a -> IO ()
+im_print_sparse x = casadi__IM__print_sparse (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__print_split" c_casadi__IM__print_split
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (Ptr (StdVec (Ptr StdString))) -> Ptr (Ptr (StdVec (Ptr StdString))) -> IO ()
+
+casadi__IM__print_split
+  :: IM -> IO (Vector String, Vector String)
+casadi__IM__print_split x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__print_split errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__IM__print_split/c_casadi__IM__print_split" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__IM__print_split/c_casadi__IM__print_split" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+-- classy wrapper
+im_print_split :: IMClass a => a -> IO (Vector String, Vector String)
+im_print_split x = casadi__IM__print_split (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__print_vector" c_casadi__IM__print_vector
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO ()
+
+casadi__IM__print_vector
+  :: IM -> IO ()
+casadi__IM__print_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__print_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_print_vector :: IMClass a => a -> IO ()
+im_print_vector x = casadi__IM__print_vector (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__printme" c_casadi__IM__printme
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__printme
+  :: IM -> IM -> IO IM
+casadi__IM__printme x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__printme errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_printme :: IMClass a => a -> IM -> IO IM
+im_printme x = casadi__IM__printme (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__remove" c_casadi__IM__remove
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__IM__remove
+  :: IM -> Vector Int -> Vector Int -> IO ()
+casadi__IM__remove x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__remove errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+im_remove :: IMClass a => a -> Vector Int -> Vector Int -> IO ()
+im_remove x = casadi__IM__remove (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__reserve__0" c_casadi__IM__reserve__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO ()
+
+casadi__IM__reserve__0
+  :: IM -> Int -> Int -> IO ()
+casadi__IM__reserve__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__reserve__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+im_reserve__0 :: IMClass a => a -> Int -> Int -> IO ()
+im_reserve__0 x = casadi__IM__reserve__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__reserve__1" c_casadi__IM__reserve__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO ()
+
+casadi__IM__reserve__1
+  :: IM -> Int -> IO ()
+casadi__IM__reserve__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__reserve__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+im_reserve__1 :: IMClass a => a -> Int -> IO ()
+im_reserve__1 x = casadi__IM__reserve__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__resetInput" c_casadi__IM__resetInput
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO ()
+
+casadi__IM__resetInput
+  :: IM -> IO ()
+casadi__IM__resetInput x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__resetInput errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_resetInput :: IMClass a => a -> IO ()
+im_resetInput x = casadi__IM__resetInput (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__resize" c_casadi__IM__resize
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO ()
+
+casadi__IM__resize
+  :: IM -> Int -> Int -> IO ()
+casadi__IM__resize x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__resize errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+im_resize :: IMClass a => a -> Int -> Int -> IO ()
+im_resize x = casadi__IM__resize (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__row" c_casadi__IM__row
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO CInt
+
+casadi__IM__row
+  :: IM -> Int -> IO Int
+casadi__IM__row x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__row errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_row :: IMClass a => a -> Int -> IO Int
+im_row x = casadi__IM__row (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sanity_check__0" c_casadi__IM__sanity_check__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO ()
+
+casadi__IM__sanity_check__0
+  :: IM -> IO ()
+casadi__IM__sanity_check__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sanity_check__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_sanity_check__0 :: IMClass a => a -> IO ()
+im_sanity_check__0 x = casadi__IM__sanity_check__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sanity_check__1" c_casadi__IM__sanity_check__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO ()
+
+casadi__IM__sanity_check__1
+  :: IM -> Bool -> IO ()
+casadi__IM__sanity_check__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sanity_check__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+im_sanity_check__1 :: IMClass a => a -> Bool -> IO ()
+im_sanity_check__1 x = casadi__IM__sanity_check__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__scalar_matrix" c_casadi__IM__scalar_matrix
+  :: Ptr (Ptr StdString) -> CInt -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__scalar_matrix
+  :: Int -> IM -> IM -> IO IM
+casadi__IM__scalar_matrix x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__scalar_matrix errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_scalar_matrix :: Int -> IM -> IM -> IO IM
+im_scalar_matrix = casadi__IM__scalar_matrix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set__0" c_casadi__IM__set__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__IM__set__0
+  :: IM -> IM -> Bool -> IM -> IM -> IO ()
+casadi__IM__set__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set__0 :: IMClass a => a -> IM -> Bool -> IM -> IM -> IO ()
+im_set__0 x = casadi__IM__set__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set__1" c_casadi__IM__set__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__IM__set__1
+  :: IM -> IM -> Bool -> IM -> Slice -> IO ()
+casadi__IM__set__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set__1 :: IMClass a => a -> IM -> Bool -> IM -> Slice -> IO ()
+im_set__1 x = casadi__IM__set__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set__2" c_casadi__IM__set__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__IM__set__2
+  :: IM -> IM -> Bool -> Slice -> IM -> IO ()
+casadi__IM__set__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set__2 :: IMClass a => a -> IM -> Bool -> Slice -> IM -> IO ()
+im_set__2 x = casadi__IM__set__2 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set__3" c_casadi__IM__set__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__IM__set__3
+  :: IM -> IM -> Bool -> Slice -> Slice -> IO ()
+casadi__IM__set__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set__3 :: IMClass a => a -> IM -> Bool -> Slice -> Slice -> IO ()
+im_set__3 x = casadi__IM__set__3 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set__4" c_casadi__IM__set__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__IM__set__4
+  :: IM -> IM -> Bool -> Sparsity -> IO ()
+casadi__IM__set__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set__4 :: IMClass a => a -> IM -> Bool -> Sparsity -> IO ()
+im_set__4 x = casadi__IM__set__4 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set__5" c_casadi__IM__set__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr IM' -> IO ()
+
+casadi__IM__set__5
+  :: IM -> IM -> Bool -> IM -> IO ()
+casadi__IM__set__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set__5 :: IMClass a => a -> IM -> Bool -> IM -> IO ()
+im_set__5 x = casadi__IM__set__5 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set__6" c_casadi__IM__set__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__IM__set__6
+  :: IM -> IM -> Bool -> Slice -> IO ()
+casadi__IM__set__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set__6 :: IMClass a => a -> IM -> Bool -> Slice -> IO ()
+im_set__6 x = casadi__IM__set__6 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__setEqualityCheckingDepth__0" c_casadi__IM__setEqualityCheckingDepth__0
+  :: Ptr (Ptr StdString) -> IO ()
+
+casadi__IM__setEqualityCheckingDepth__0
+  :: IO ()
+casadi__IM__setEqualityCheckingDepth__0  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__setEqualityCheckingDepth__0 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ()
+
+
+
+-- classy wrapper
+im_setEqualityCheckingDepth__0 :: IO ()
+im_setEqualityCheckingDepth__0 = casadi__IM__setEqualityCheckingDepth__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__setEqualityCheckingDepth__1" c_casadi__IM__setEqualityCheckingDepth__1
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__IM__setEqualityCheckingDepth__1
+  :: Int -> IO ()
+casadi__IM__setEqualityCheckingDepth__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__setEqualityCheckingDepth__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_setEqualityCheckingDepth__1 :: Int -> IO ()
+im_setEqualityCheckingDepth__1 = casadi__IM__setEqualityCheckingDepth__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__setPrecision" c_casadi__IM__setPrecision
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__IM__setPrecision
+  :: Int -> IO ()
+casadi__IM__setPrecision x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__setPrecision errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_setPrecision :: Int -> IO ()
+im_setPrecision = casadi__IM__setPrecision
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__setScientific" c_casadi__IM__setScientific
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__IM__setScientific
+  :: Bool -> IO ()
+casadi__IM__setScientific x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__setScientific errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_setScientific :: Bool -> IO ()
+im_setScientific = casadi__IM__setScientific
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__setWidth" c_casadi__IM__setWidth
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__IM__setWidth
+  :: Int -> IO ()
+casadi__IM__setWidth x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__setWidth errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+im_setWidth :: Int -> IO ()
+im_setWidth = casadi__IM__setWidth
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set_nz__0" c_casadi__IM__set_nz__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr IM' -> IO ()
+
+casadi__IM__set_nz__0
+  :: IM -> IM -> Bool -> IM -> IO ()
+casadi__IM__set_nz__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set_nz__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set_nz__0 :: IMClass a => a -> IM -> Bool -> IM -> IO ()
+im_set_nz__0 x = casadi__IM__set_nz__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__set_nz__1" c_casadi__IM__set_nz__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__IM__set_nz__1
+  :: IM -> IM -> Bool -> Slice -> IO ()
+casadi__IM__set_nz__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__set_nz__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+im_set_nz__1 :: IMClass a => a -> IM -> Bool -> Slice -> IO ()
+im_set_nz__1 x = casadi__IM__set_nz__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__size__0" c_casadi__IM__size__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO CInt
+
+casadi__IM__size__0
+  :: IM -> Int -> IO Int
+casadi__IM__size__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__size__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_size__0 :: IMClass a => a -> Int -> IO Int
+im_size__0 x = casadi__IM__size__0 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__size__1" c_casadi__IM__size__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdPair CInt CInt))
+
+casadi__IM__size__1
+  :: IM -> IO (Int, Int)
+casadi__IM__size__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__size__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_size__1 :: IMClass a => a -> IO (Int, Int)
+im_size__1 x = casadi__IM__size__1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__size1" c_casadi__IM__size1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__size1
+  :: IM -> IO Int
+casadi__IM__size1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__size1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_size1 :: IMClass a => a -> IO Int
+im_size1 x = casadi__IM__size1 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__size2" c_casadi__IM__size2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi__IM__size2
+  :: IM -> IO Int
+casadi__IM__size2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__size2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_size2 :: IMClass a => a -> IO Int
+im_size2 x = casadi__IM__size2 (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sparsity" c_casadi__IM__sparsity
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr Sparsity')
+
+casadi__IM__sparsity
+  :: IM -> IO Sparsity
+casadi__IM__sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sparsity :: IMClass a => a -> IO Sparsity
+im_sparsity x = casadi__IM__sparsity (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__0" c_casadi__IM__sym__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IM')))))
+
+casadi__IM__sym__0
+  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IM))
+casadi__IM__sym__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IM))
+im_sym__0 = casadi__IM__sym__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__1" c_casadi__IM__sym__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IM')))))
+
+casadi__IM__sym__1
+  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IM))
+casadi__IM__sym__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IM))
+im_sym__1 = casadi__IM__sym__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__2" c_casadi__IM__sym__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi__IM__sym__2
+  :: String -> Int -> Int -> Int -> IO (Vector IM)
+casadi__IM__sym__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__2 :: String -> Int -> Int -> Int -> IO (Vector IM)
+im_sym__2 = casadi__IM__sym__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__3" c_casadi__IM__sym__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi__IM__sym__3
+  :: String -> Sparsity -> Int -> IO (Vector IM)
+casadi__IM__sym__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__3 :: String -> Sparsity -> Int -> IO (Vector IM)
+im_sym__3 = casadi__IM__sym__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__4" c_casadi__IM__sym__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi__IM__sym__4
+  :: String -> Sparsity -> IO IM
+casadi__IM__sym__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__4 :: String -> Sparsity -> IO IM
+im_sym__4 = casadi__IM__sym__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__5" c_casadi__IM__sym__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi__IM__sym__5
+  :: String -> (Int, Int) -> IO IM
+casadi__IM__sym__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__5 :: String -> (Int, Int) -> IO IM
+im_sym__5 = casadi__IM__sym__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__6" c_casadi__IM__sym__6
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__sym__6
+  :: String -> IO IM
+casadi__IM__sym__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__6 :: String -> IO IM
+im_sym__6 = casadi__IM__sym__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__7" c_casadi__IM__sym__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr IM')
+
+casadi__IM__sym__7
+  :: String -> Int -> IO IM
+casadi__IM__sym__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__7 :: String -> Int -> IO IM
+im_sym__7 = casadi__IM__sym__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__sym__8" c_casadi__IM__sym__8
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__sym__8
+  :: String -> Int -> Int -> IO IM
+casadi__IM__sym__8 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__sym__8 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_sym__8 :: String -> Int -> Int -> IO IM
+im_sym__8 = casadi__IM__sym__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__tang__0" c_casadi__IM__tang__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__tang__0
+  :: Function -> String -> String -> IO IM
+casadi__IM__tang__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__tang__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_tang__0 :: Function -> String -> String -> IO IM
+im_tang__0 = casadi__IM__tang__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__tang__1" c_casadi__IM__tang__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__tang__1
+  :: Function -> Int -> String -> IO IM
+casadi__IM__tang__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__tang__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_tang__1 :: Function -> Int -> String -> IO IM
+im_tang__1 = casadi__IM__tang__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__tang__2" c_casadi__IM__tang__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr IM')
+
+casadi__IM__tang__2
+  :: Function -> String -> IO IM
+casadi__IM__tang__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__tang__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_tang__2 :: Function -> String -> IO IM
+im_tang__2 = casadi__IM__tang__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__tang__3" c_casadi__IM__tang__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr IM')
+
+casadi__IM__tang__3
+  :: Function -> String -> Int -> IO IM
+casadi__IM__tang__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__tang__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_tang__3 :: Function -> String -> Int -> IO IM
+im_tang__3 = casadi__IM__tang__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__tang__4" c_casadi__IM__tang__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IM')
+
+casadi__IM__tang__4
+  :: Function -> IO IM
+casadi__IM__tang__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__tang__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_tang__4 :: Function -> IO IM
+im_tang__4 = casadi__IM__tang__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__tang__5" c_casadi__IM__tang__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr IM')
+
+casadi__IM__tang__5
+  :: Function -> Int -> IO IM
+casadi__IM__tang__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__tang__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_tang__5 :: Function -> Int -> IO IM
+im_tang__5 = casadi__IM__tang__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__tang__6" c_casadi__IM__tang__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__tang__6
+  :: Function -> Int -> Int -> IO IM
+casadi__IM__tang__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__tang__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_tang__6 :: Function -> Int -> Int -> IO IM
+im_tang__6 = casadi__IM__tang__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__triplet__0" c_casadi__IM__triplet__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IM' -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi__IM__triplet__0
+  :: Vector Int -> Vector Int -> IM -> (Int, Int) -> IO IM
+casadi__IM__triplet__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__triplet__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+im_triplet__0 :: Vector Int -> Vector Int -> IM -> (Int, Int) -> IO IM
+im_triplet__0 = casadi__IM__triplet__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__triplet__1" c_casadi__IM__triplet__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IM' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__triplet__1
+  :: Vector Int -> Vector Int -> IM -> Int -> Int -> IO IM
+casadi__IM__triplet__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+im_triplet__1 :: Vector Int -> Vector Int -> IM -> Int -> Int -> IO IM
+im_triplet__1 = casadi__IM__triplet__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__triplet__2" c_casadi__IM__triplet__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__triplet__2
+  :: Vector Int -> Vector Int -> IM -> IO IM
+casadi__IM__triplet__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__triplet__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+im_triplet__2 :: Vector Int -> Vector Int -> IM -> IO IM
+im_triplet__2 = casadi__IM__triplet__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__type_name" c_casadi__IM__type_name
+  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
+casadi__IM__type_name
+  :: IO String
+casadi__IM__type_name  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__type_name errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+im_type_name :: IO String
+im_type_name = casadi__IM__type_name
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__unary" c_casadi__IM__unary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr IM' -> IO (Ptr IM')
+
+casadi__IM__unary
+  :: Int -> IM -> IO IM
+casadi__IM__unary x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__unary errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_unary :: Int -> IM -> IO IM
+im_unary = casadi__IM__unary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__zeros__0" c_casadi__IM__zeros__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi__IM__zeros__0
+  :: (Int, Int) -> IO IM
+casadi__IM__zeros__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__zeros__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_zeros__0 :: (Int, Int) -> IO IM
+im_zeros__0 = casadi__IM__zeros__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__zeros__1" c_casadi__IM__zeros__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi__IM__zeros__1
+  :: Sparsity -> IO IM
+casadi__IM__zeros__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__zeros__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_zeros__1 :: Sparsity -> IO IM
+im_zeros__1 = casadi__IM__zeros__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__zeros__2" c_casadi__IM__zeros__2
+  :: Ptr (Ptr StdString) -> IO (Ptr IM')
+
+casadi__IM__zeros__2
+  :: IO IM
+casadi__IM__zeros__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__zeros__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+im_zeros__2 :: IO IM
+im_zeros__2 = casadi__IM__zeros__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__zeros__3" c_casadi__IM__zeros__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IM')
+
+casadi__IM__zeros__3
+  :: Int -> IO IM
+casadi__IM__zeros__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__zeros__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_zeros__3 :: Int -> IO IM
+im_zeros__3 = casadi__IM__zeros__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__zeros__4" c_casadi__IM__zeros__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IM')
+
+casadi__IM__zeros__4
+  :: Int -> Int -> IO IM
+casadi__IM__zeros__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__zeros__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+im_zeros__4 :: Int -> Int -> IO IM
+im_zeros__4 = casadi__IM__zeros__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__getRepresentation" c_casadi__IM__getRepresentation
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr StdString)
+
+casadi__IM__getRepresentation
+  :: IM -> IO String
+casadi__IM__getRepresentation x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_getRepresentation :: IMClass a => a -> IO String
+im_getRepresentation x = casadi__IM__getRepresentation (castIM x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__IM__getDescription" c_casadi__IM__getDescription
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr StdString)
+
+casadi__IM__getDescription
+  :: IM -> IO String
+casadi__IM__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__IM__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+im_getDescription :: IMClass a => a -> IO String
+im_getDescription x = casadi__IM__getDescription (castIM x)
+
diff --git a/Casadi/Core/Classes/IMatrix.hs b/Casadi/Core/Classes/IMatrix.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/IMatrix.hs
+++ /dev/null
@@ -1,3931 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.IMatrix
-       (
-         IMatrix,
-         IMatrixClass(..),
-         imatrix_T,
-         imatrix__0,
-         imatrix__1,
-         imatrix__2,
-         imatrix__3,
-         imatrix__4,
-         imatrix__5,
-         imatrix__6,
-         imatrix___nonzero__,
-         imatrix_append,
-         imatrix_appendColumns,
-         imatrix_binary,
-         imatrix_className,
-         imatrix_clear,
-         imatrix_colind,
-         imatrix_dimString,
-         imatrix_enlarge__0,
-         imatrix_enlarge__1,
-         imatrix_erase__0,
-         imatrix_erase__1,
-         imatrix_erase__2,
-         imatrix_erase__3,
-         imatrix_eye,
-         imatrix_find__0,
-         imatrix_find__1,
-         imatrix_getColind,
-         imatrix_getDep__0,
-         imatrix_getDep__1,
-         imatrix_getDescription,
-         imatrix_getElementHash,
-         imatrix_getEqualityCheckingDepth,
-         imatrix_getIntValue,
-         imatrix_getNZ__0,
-         imatrix_getNZ__1,
-         imatrix_getNZ__2,
-         imatrix_getName,
-         imatrix_getNdeps,
-         imatrix_getRepresentation,
-         imatrix_getRow,
-         imatrix_getSparsity,
-         imatrix_getSym,
-         imatrix_getValue__0,
-         imatrix_getValue__1,
-         imatrix_get__0,
-         imatrix_get__1,
-         imatrix_get__2,
-         imatrix_get__3,
-         imatrix_get__4,
-         imatrix_get__5,
-         imatrix_get__6,
-         imatrix_get__7,
-         imatrix_hasDuplicates,
-         imatrix_hasNZ,
-         imatrix_hasNonStructuralZeros,
-         imatrix_inf__0,
-         imatrix_inf__1,
-         imatrix_inf__2,
-         imatrix_inf__3,
-         imatrix_inf__4,
-         imatrix_isCommutative,
-         imatrix_isConstant,
-         imatrix_isIdentity,
-         imatrix_isInteger,
-         imatrix_isLeaf,
-         imatrix_isMinusOne,
-         imatrix_isOne,
-         imatrix_isRegular,
-         imatrix_isSlice__0,
-         imatrix_isSlice__1,
-         imatrix_isSmooth,
-         imatrix_isSymbolic,
-         imatrix_isValidInput,
-         imatrix_isZero,
-         imatrix_iscolumn,
-         imatrix_isdense,
-         imatrix_isempty__0,
-         imatrix_isempty__1,
-         imatrix_isrow,
-         imatrix_isscalar__0,
-         imatrix_isscalar__1,
-         imatrix_issquare,
-         imatrix_istril,
-         imatrix_istriu,
-         imatrix_isvector,
-         imatrix_makeSparse__0,
-         imatrix_makeSparse__1,
-         imatrix_matrix_matrix,
-         imatrix_matrix_scalar,
-         imatrix_nan__0,
-         imatrix_nan__1,
-         imatrix_nan__2,
-         imatrix_nan__3,
-         imatrix_nan__4,
-         imatrix_nnz,
-         imatrix_nonzeros,
-         imatrix_nonzeros_int,
-         imatrix_numel__0,
-         imatrix_numel__1,
-         imatrix_ones__0,
-         imatrix_ones__1,
-         imatrix_ones__2,
-         imatrix_ones__3,
-         imatrix_ones__4,
-         imatrix_operator_minus,
-         imatrix_operator_plus,
-         imatrix_printDense,
-         imatrix_printScalar,
-         imatrix_printSparse,
-         imatrix_printSplit,
-         imatrix_printVector,
-         imatrix_printme,
-         imatrix_remove,
-         imatrix_reserve__0,
-         imatrix_reserve__1,
-         imatrix_resetInput,
-         imatrix_resize,
-         imatrix_row,
-         imatrix_sanityCheck__0,
-         imatrix_sanityCheck__1,
-         imatrix_scalar_matrix,
-         imatrix_setEqualityCheckingDepth__0,
-         imatrix_setEqualityCheckingDepth__1,
-         imatrix_setNZ__0,
-         imatrix_setNZ__1,
-         imatrix_setNZ__2,
-         imatrix_setNZ__3,
-         imatrix_setPrecision,
-         imatrix_setScientific,
-         imatrix_setSym,
-         imatrix_setValue__0,
-         imatrix_setValue__1,
-         imatrix_setWidth,
-         imatrix_setZero,
-         imatrix_set__0,
-         imatrix_set__1,
-         imatrix_set__10,
-         imatrix_set__2,
-         imatrix_set__3,
-         imatrix_set__4,
-         imatrix_set__5,
-         imatrix_set__6,
-         imatrix_set__7,
-         imatrix_set__8,
-         imatrix_set__9,
-         imatrix_shape__0,
-         imatrix_shape__1,
-         imatrix_size,
-         imatrix_size1,
-         imatrix_size2,
-         imatrix_sizeD,
-         imatrix_sizeL,
-         imatrix_sizeU,
-         imatrix_sparse__0,
-         imatrix_sparse__1,
-         imatrix_sparse__2,
-         imatrix_sparse__3,
-         imatrix_sparse__4,
-         imatrix_sparsity,
-         imatrix_sym__0,
-         imatrix_sym__1,
-         imatrix_sym__2,
-         imatrix_sym__3,
-         imatrix_sym__4,
-         imatrix_sym__5,
-         imatrix_sym__6,
-         imatrix_sym__7,
-         imatrix_sym__8,
-         imatrix_toSlice__0,
-         imatrix_toSlice__1,
-         imatrix_triplet__0,
-         imatrix_triplet__1,
-         imatrix_triplet__2,
-         imatrix_unary,
-         imatrix_zeros__0,
-         imatrix_zeros__1,
-         imatrix_zeros__2,
-         imatrix_zeros__3,
-         imatrix_zeros__4,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__0" c_casadi__IMatrix__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr IMatrix')
-casadi__IMatrix__CONSTRUCTOR__0
-  :: Vector (Vector Double) -> IO IMatrix
-casadi__IMatrix__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix__0 :: Vector (Vector Double) -> IO IMatrix
-imatrix__0 = casadi__IMatrix__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__1" c_casadi__IMatrix__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr IMatrix')
-casadi__IMatrix__CONSTRUCTOR__1
-  :: Double -> IO IMatrix
-casadi__IMatrix__CONSTRUCTOR__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__CONSTRUCTOR__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix__1 :: Double -> IO IMatrix
-imatrix__1 = casadi__IMatrix__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__2" c_casadi__IMatrix__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__CONSTRUCTOR__2
-  :: Sparsity -> IMatrix -> IO IMatrix
-casadi__IMatrix__CONSTRUCTOR__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__CONSTRUCTOR__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix__2 :: Sparsity -> IMatrix -> IO IMatrix
-imatrix__2 = casadi__IMatrix__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__3" c_casadi__IMatrix__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi__IMatrix__CONSTRUCTOR__3
-  :: Sparsity -> IO IMatrix
-casadi__IMatrix__CONSTRUCTOR__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__CONSTRUCTOR__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix__3 :: Sparsity -> IO IMatrix
-imatrix__3 = casadi__IMatrix__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__4" c_casadi__IMatrix__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__CONSTRUCTOR__4
-  :: Int -> Int -> IO IMatrix
-casadi__IMatrix__CONSTRUCTOR__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__CONSTRUCTOR__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix__4 :: Int -> Int -> IO IMatrix
-imatrix__4 = casadi__IMatrix__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__5" c_casadi__IMatrix__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__CONSTRUCTOR__5
-  :: IMatrix -> IO IMatrix
-casadi__IMatrix__CONSTRUCTOR__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__CONSTRUCTOR__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix__5 :: IMatrix -> IO IMatrix
-imatrix__5 = casadi__IMatrix__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__6" c_casadi__IMatrix__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
-casadi__IMatrix__CONSTRUCTOR__6
-  :: IO IMatrix
-casadi__IMatrix__CONSTRUCTOR__6  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__CONSTRUCTOR__6 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix__6 :: IO IMatrix
-imatrix__6 = casadi__IMatrix__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__T" c_casadi__IMatrix__T
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__T
-  :: IMatrix -> IO IMatrix
-casadi__IMatrix__T x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__T errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_T :: IMatrixClass a => a -> IO IMatrix
-imatrix_T x = casadi__IMatrix__T (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix____nonzero__" c_casadi__IMatrix____nonzero__
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix____nonzero__
-  :: IMatrix -> IO Bool
-casadi__IMatrix____nonzero__ x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix____nonzero__ errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix___nonzero__ :: IMatrixClass a => a -> IO Bool
-imatrix___nonzero__ x = casadi__IMatrix____nonzero__ (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__append" c_casadi__IMatrix__append
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__append
-  :: IMatrix -> IMatrix -> IO ()
-casadi__IMatrix__append x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__append errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_append :: IMatrixClass a => a -> IMatrix -> IO ()
-imatrix_append x = casadi__IMatrix__append (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__appendColumns" c_casadi__IMatrix__appendColumns
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__appendColumns
-  :: IMatrix -> IMatrix -> IO ()
-casadi__IMatrix__appendColumns x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__appendColumns errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_appendColumns :: IMatrixClass a => a -> IMatrix -> IO ()
-imatrix_appendColumns x = casadi__IMatrix__appendColumns (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__binary" c_casadi__IMatrix__binary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__binary
-  :: Int -> IMatrix -> IMatrix -> IO IMatrix
-casadi__IMatrix__binary x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__binary errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_binary :: Int -> IMatrix -> IMatrix -> IO IMatrix
-imatrix_binary = casadi__IMatrix__binary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__className" c_casadi__IMatrix__className
-  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
-casadi__IMatrix__className
-  :: IO String
-casadi__IMatrix__className  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__className errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_className :: IO String
-imatrix_className = casadi__IMatrix__className
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__clear" c_casadi__IMatrix__clear
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__clear
-  :: IMatrix -> IO ()
-casadi__IMatrix__clear x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__clear errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_clear :: IMatrixClass a => a -> IO ()
-imatrix_clear x = casadi__IMatrix__clear (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__colind" c_casadi__IMatrix__colind
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt
-casadi__IMatrix__colind
-  :: IMatrix -> Int -> IO Int
-casadi__IMatrix__colind x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__colind errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_colind :: IMatrixClass a => a -> Int -> IO Int
-imatrix_colind x = casadi__IMatrix__colind (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__dimString" c_casadi__IMatrix__dimString
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString)
-casadi__IMatrix__dimString
-  :: IMatrix -> IO String
-casadi__IMatrix__dimString x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__dimString errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_dimString :: IMatrixClass a => a -> IO String
-imatrix_dimString x = casadi__IMatrix__dimString (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__enlarge__0" c_casadi__IMatrix__enlarge__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__IMatrix__enlarge__0
-  :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-casadi__IMatrix__enlarge__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_enlarge__0 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-imatrix_enlarge__0 x = casadi__IMatrix__enlarge__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__enlarge__1" c_casadi__IMatrix__enlarge__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__IMatrix__enlarge__1
-  :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__IMatrix__enlarge__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_enlarge__1 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-imatrix_enlarge__1 x = casadi__IMatrix__enlarge__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__erase__0" c_casadi__IMatrix__erase__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO ()
-casadi__IMatrix__erase__0
-  :: IMatrix -> Vector Int -> IO ()
-casadi__IMatrix__erase__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__erase__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_erase__0 :: IMatrixClass a => a -> Vector Int -> IO ()
-imatrix_erase__0 x = casadi__IMatrix__erase__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__erase__1" c_casadi__IMatrix__erase__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__IMatrix__erase__1
-  :: IMatrix -> Vector Int -> Bool -> IO ()
-casadi__IMatrix__erase__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__erase__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_erase__1 :: IMatrixClass a => a -> Vector Int -> Bool -> IO ()
-imatrix_erase__1 x = casadi__IMatrix__erase__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__erase__2" c_casadi__IMatrix__erase__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__IMatrix__erase__2
-  :: IMatrix -> Vector Int -> Vector Int -> IO ()
-casadi__IMatrix__erase__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__erase__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_erase__2 :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
-imatrix_erase__2 x = casadi__IMatrix__erase__2 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__erase__3" c_casadi__IMatrix__erase__3
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__IMatrix__erase__3
-  :: IMatrix -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__IMatrix__erase__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__erase__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_erase__3 :: IMatrixClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
-imatrix_erase__3 x = casadi__IMatrix__erase__3 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__eye" c_casadi__IMatrix__eye
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__eye
-  :: Int -> IO IMatrix
-casadi__IMatrix__eye x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__eye errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_eye :: Int -> IO IMatrix
-imatrix_eye = casadi__IMatrix__eye
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__find__0" c_casadi__IMatrix__find__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt))
-casadi__IMatrix__find__0
-  :: IMatrix -> IO (Vector Int)
-casadi__IMatrix__find__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__find__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_find__0 :: IMatrixClass a => a -> IO (Vector Int)
-imatrix_find__0 x = casadi__IMatrix__find__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__find__1" c_casadi__IMatrix__find__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__IMatrix__find__1
-  :: IMatrix -> Bool -> IO (Vector Int)
-casadi__IMatrix__find__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__find__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_find__1 :: IMatrixClass a => a -> Bool -> IO (Vector Int)
-imatrix_find__1 x = casadi__IMatrix__find__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__0" c_casadi__IMatrix__get__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__get__0
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__IMatrix__get__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-imatrix_get__0 x = casadi__IMatrix__get__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__1" c_casadi__IMatrix__get__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__IMatrix__get__1
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO ()
-casadi__IMatrix__get__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> IO ()
-imatrix_get__1 x = casadi__IMatrix__get__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__2" c_casadi__IMatrix__get__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__get__2
-  :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO ()
-casadi__IMatrix__get__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> IO ()
-imatrix_get__2 x = casadi__IMatrix__get__2 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__3" c_casadi__IMatrix__get__3
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__IMatrix__get__3
-  :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO ()
-casadi__IMatrix__get__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> IO ()
-imatrix_get__3 x = casadi__IMatrix__get__3 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__4" c_casadi__IMatrix__get__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__IMatrix__get__4
-  :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO ()
-casadi__IMatrix__get__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> IO ()
-imatrix_get__4 x = casadi__IMatrix__get__4 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__5" c_casadi__IMatrix__get__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__get__5
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO ()
-casadi__IMatrix__get__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO ()
-imatrix_get__5 x = casadi__IMatrix__get__5 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__6" c_casadi__IMatrix__get__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__IMatrix__get__6
-  :: IMatrix -> IMatrix -> Bool -> Slice -> IO ()
-casadi__IMatrix__get__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO ()
-imatrix_get__6 x = casadi__IMatrix__get__6 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__get__7" c_casadi__IMatrix__get__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__IMatrix__get__7
-  :: IMatrix -> Vector Double -> IO ()
-casadi__IMatrix__get__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__get__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_get__7 :: IMatrixClass a => a -> Vector Double -> IO ()
-imatrix_get__7 x = casadi__IMatrix__get__7 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getColind" c_casadi__IMatrix__getColind
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt))
-casadi__IMatrix__getColind
-  :: IMatrix -> IO (Vector Int)
-casadi__IMatrix__getColind x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getColind errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getColind :: IMatrixClass a => a -> IO (Vector Int)
-imatrix_getColind x = casadi__IMatrix__getColind (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getDep__0" c_casadi__IMatrix__getDep__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__getDep__0
-  :: IMatrix -> IO IMatrix
-casadi__IMatrix__getDep__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getDep__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getDep__0 :: IMatrixClass a => a -> IO IMatrix
-imatrix_getDep__0 x = casadi__IMatrix__getDep__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getDep__1" c_casadi__IMatrix__getDep__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__getDep__1
-  :: IMatrix -> Int -> IO IMatrix
-casadi__IMatrix__getDep__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getDep__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getDep__1 :: IMatrixClass a => a -> Int -> IO IMatrix
-imatrix_getDep__1 x = casadi__IMatrix__getDep__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getElementHash" c_casadi__IMatrix__getElementHash
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CSize
-casadi__IMatrix__getElementHash
-  :: IMatrix -> IO CSize
-casadi__IMatrix__getElementHash x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getElementHash errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getElementHash :: IMatrixClass a => a -> IO CSize
-imatrix_getElementHash x = casadi__IMatrix__getElementHash (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getEqualityCheckingDepth" c_casadi__IMatrix__getEqualityCheckingDepth
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__IMatrix__getEqualityCheckingDepth
-  :: IO Int
-casadi__IMatrix__getEqualityCheckingDepth  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getEqualityCheckingDepth errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getEqualityCheckingDepth :: IO Int
-imatrix_getEqualityCheckingDepth = casadi__IMatrix__getEqualityCheckingDepth
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getIntValue" c_casadi__IMatrix__getIntValue
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__getIntValue
-  :: IMatrix -> IO Int
-casadi__IMatrix__getIntValue x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getIntValue errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getIntValue :: IMatrixClass a => a -> IO Int
-imatrix_getIntValue x = casadi__IMatrix__getIntValue (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getNZ__0" c_casadi__IMatrix__getNZ__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__getNZ__0
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO ()
-casadi__IMatrix__getNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO ()
-imatrix_getNZ__0 x = casadi__IMatrix__getNZ__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getNZ__1" c_casadi__IMatrix__getNZ__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__IMatrix__getNZ__1
-  :: IMatrix -> IMatrix -> Bool -> Slice -> IO ()
-casadi__IMatrix__getNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO ()
-imatrix_getNZ__1 x = casadi__IMatrix__getNZ__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getNZ__2" c_casadi__IMatrix__getNZ__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__IMatrix__getNZ__2
-  :: IMatrix -> Vector Double -> IO ()
-casadi__IMatrix__getNZ__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getNZ__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getNZ__2 :: IMatrixClass a => a -> Vector Double -> IO ()
-imatrix_getNZ__2 x = casadi__IMatrix__getNZ__2 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getName" c_casadi__IMatrix__getName
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString)
-casadi__IMatrix__getName
-  :: IMatrix -> IO String
-casadi__IMatrix__getName x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getName errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getName :: IMatrixClass a => a -> IO String
-imatrix_getName x = casadi__IMatrix__getName (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getNdeps" c_casadi__IMatrix__getNdeps
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__getNdeps
-  :: IMatrix -> IO Int
-casadi__IMatrix__getNdeps x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getNdeps errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getNdeps :: IMatrixClass a => a -> IO Int
-imatrix_getNdeps x = casadi__IMatrix__getNdeps (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getRow" c_casadi__IMatrix__getRow
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt))
-casadi__IMatrix__getRow
-  :: IMatrix -> IO (Vector Int)
-casadi__IMatrix__getRow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getRow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getRow :: IMatrixClass a => a -> IO (Vector Int)
-imatrix_getRow x = casadi__IMatrix__getRow (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getSparsity" c_casadi__IMatrix__getSparsity
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity')
-casadi__IMatrix__getSparsity
-  :: IMatrix -> IO Sparsity
-casadi__IMatrix__getSparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getSparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getSparsity :: IMatrixClass a => a -> IO Sparsity
-imatrix_getSparsity x = casadi__IMatrix__getSparsity (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getSym" c_casadi__IMatrix__getSym
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__IMatrix__getSym
-  :: IMatrix -> Vector Double -> IO ()
-casadi__IMatrix__getSym x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getSym errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getSym :: IMatrixClass a => a -> Vector Double -> IO ()
-imatrix_getSym x = casadi__IMatrix__getSym (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getValue__0" c_casadi__IMatrix__getValue__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CDouble
-casadi__IMatrix__getValue__0
-  :: IMatrix -> Int -> IO Double
-casadi__IMatrix__getValue__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getValue__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getValue__0 :: IMatrixClass a => a -> Int -> IO Double
-imatrix_getValue__0 x = casadi__IMatrix__getValue__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getValue__1" c_casadi__IMatrix__getValue__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CDouble
-casadi__IMatrix__getValue__1
-  :: IMatrix -> IO Double
-casadi__IMatrix__getValue__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getValue__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getValue__1 :: IMatrixClass a => a -> IO Double
-imatrix_getValue__1 x = casadi__IMatrix__getValue__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__hasDuplicates" c_casadi__IMatrix__hasDuplicates
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__hasDuplicates
-  :: IMatrix -> IO Bool
-casadi__IMatrix__hasDuplicates x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__hasDuplicates errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_hasDuplicates :: IMatrixClass a => a -> IO Bool
-imatrix_hasDuplicates x = casadi__IMatrix__hasDuplicates (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__hasNZ" c_casadi__IMatrix__hasNZ
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt
-casadi__IMatrix__hasNZ
-  :: IMatrix -> Int -> Int -> IO Bool
-casadi__IMatrix__hasNZ x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__hasNZ errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_hasNZ :: IMatrixClass a => a -> Int -> Int -> IO Bool
-imatrix_hasNZ x = casadi__IMatrix__hasNZ (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__hasNonStructuralZeros" c_casadi__IMatrix__hasNonStructuralZeros
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__hasNonStructuralZeros
-  :: IMatrix -> IO Bool
-casadi__IMatrix__hasNonStructuralZeros x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__hasNonStructuralZeros errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_hasNonStructuralZeros :: IMatrixClass a => a -> IO Bool
-imatrix_hasNonStructuralZeros x = casadi__IMatrix__hasNonStructuralZeros (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__inf__0" c_casadi__IMatrix__inf__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi__IMatrix__inf__0
-  :: (Int, Int) -> IO IMatrix
-casadi__IMatrix__inf__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__inf__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_inf__0 :: (Int, Int) -> IO IMatrix
-imatrix_inf__0 = casadi__IMatrix__inf__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__inf__1" c_casadi__IMatrix__inf__1
-  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
-casadi__IMatrix__inf__1
-  :: IO IMatrix
-casadi__IMatrix__inf__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__inf__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_inf__1 :: IO IMatrix
-imatrix_inf__1 = casadi__IMatrix__inf__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__inf__2" c_casadi__IMatrix__inf__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__inf__2
-  :: Int -> IO IMatrix
-casadi__IMatrix__inf__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__inf__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_inf__2 :: Int -> IO IMatrix
-imatrix_inf__2 = casadi__IMatrix__inf__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__inf__3" c_casadi__IMatrix__inf__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__inf__3
-  :: Int -> Int -> IO IMatrix
-casadi__IMatrix__inf__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__inf__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_inf__3 :: Int -> Int -> IO IMatrix
-imatrix_inf__3 = casadi__IMatrix__inf__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__inf__4" c_casadi__IMatrix__inf__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi__IMatrix__inf__4
-  :: Sparsity -> IO IMatrix
-casadi__IMatrix__inf__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__inf__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_inf__4 :: Sparsity -> IO IMatrix
-imatrix_inf__4 = casadi__IMatrix__inf__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isCommutative" c_casadi__IMatrix__isCommutative
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isCommutative
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isCommutative x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isCommutative errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isCommutative :: IMatrixClass a => a -> IO Bool
-imatrix_isCommutative x = casadi__IMatrix__isCommutative (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isConstant" c_casadi__IMatrix__isConstant
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isConstant
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isConstant x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isConstant errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isConstant :: IMatrixClass a => a -> IO Bool
-imatrix_isConstant x = casadi__IMatrix__isConstant (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isIdentity" c_casadi__IMatrix__isIdentity
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isIdentity
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isIdentity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isIdentity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isIdentity :: IMatrixClass a => a -> IO Bool
-imatrix_isIdentity x = casadi__IMatrix__isIdentity (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isInteger" c_casadi__IMatrix__isInteger
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isInteger
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isInteger x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isInteger errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isInteger :: IMatrixClass a => a -> IO Bool
-imatrix_isInteger x = casadi__IMatrix__isInteger (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isLeaf" c_casadi__IMatrix__isLeaf
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isLeaf
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isLeaf x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isLeaf errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isLeaf :: IMatrixClass a => a -> IO Bool
-imatrix_isLeaf x = casadi__IMatrix__isLeaf (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isMinusOne" c_casadi__IMatrix__isMinusOne
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isMinusOne
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isMinusOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isMinusOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isMinusOne :: IMatrixClass a => a -> IO Bool
-imatrix_isMinusOne x = casadi__IMatrix__isMinusOne (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isOne" c_casadi__IMatrix__isOne
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isOne
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isOne :: IMatrixClass a => a -> IO Bool
-imatrix_isOne x = casadi__IMatrix__isOne (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isRegular" c_casadi__IMatrix__isRegular
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isRegular
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isRegular x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isRegular errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isRegular :: IMatrixClass a => a -> IO Bool
-imatrix_isRegular x = casadi__IMatrix__isRegular (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isSlice__0" c_casadi__IMatrix__isSlice__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isSlice__0
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isSlice__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isSlice__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isSlice__0 :: IMatrixClass a => a -> IO Bool
-imatrix_isSlice__0 x = casadi__IMatrix__isSlice__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isSlice__1" c_casadi__IMatrix__isSlice__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt
-casadi__IMatrix__isSlice__1
-  :: IMatrix -> Bool -> IO Bool
-casadi__IMatrix__isSlice__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isSlice__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isSlice__1 :: IMatrixClass a => a -> Bool -> IO Bool
-imatrix_isSlice__1 x = casadi__IMatrix__isSlice__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isSmooth" c_casadi__IMatrix__isSmooth
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isSmooth
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isSmooth x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isSmooth errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isSmooth :: IMatrixClass a => a -> IO Bool
-imatrix_isSmooth x = casadi__IMatrix__isSmooth (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isSymbolic" c_casadi__IMatrix__isSymbolic
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isSymbolic
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isSymbolic x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isSymbolic errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isSymbolic :: IMatrixClass a => a -> IO Bool
-imatrix_isSymbolic x = casadi__IMatrix__isSymbolic (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isValidInput" c_casadi__IMatrix__isValidInput
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isValidInput
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isValidInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isValidInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isValidInput :: IMatrixClass a => a -> IO Bool
-imatrix_isValidInput x = casadi__IMatrix__isValidInput (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isZero" c_casadi__IMatrix__isZero
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isZero
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isZero x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isZero errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isZero :: IMatrixClass a => a -> IO Bool
-imatrix_isZero x = casadi__IMatrix__isZero (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__iscolumn" c_casadi__IMatrix__iscolumn
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__iscolumn
-  :: IMatrix -> IO Bool
-casadi__IMatrix__iscolumn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__iscolumn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_iscolumn :: IMatrixClass a => a -> IO Bool
-imatrix_iscolumn x = casadi__IMatrix__iscolumn (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isdense" c_casadi__IMatrix__isdense
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isdense
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isdense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isdense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isdense :: IMatrixClass a => a -> IO Bool
-imatrix_isdense x = casadi__IMatrix__isdense (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isempty__0" c_casadi__IMatrix__isempty__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isempty__0
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isempty__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isempty__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isempty__0 :: IMatrixClass a => a -> IO Bool
-imatrix_isempty__0 x = casadi__IMatrix__isempty__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isempty__1" c_casadi__IMatrix__isempty__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt
-casadi__IMatrix__isempty__1
-  :: IMatrix -> Bool -> IO Bool
-casadi__IMatrix__isempty__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isempty__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isempty__1 :: IMatrixClass a => a -> Bool -> IO Bool
-imatrix_isempty__1 x = casadi__IMatrix__isempty__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isrow" c_casadi__IMatrix__isrow
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isrow
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isrow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isrow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isrow :: IMatrixClass a => a -> IO Bool
-imatrix_isrow x = casadi__IMatrix__isrow (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isscalar__0" c_casadi__IMatrix__isscalar__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isscalar__0
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isscalar__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isscalar__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isscalar__0 :: IMatrixClass a => a -> IO Bool
-imatrix_isscalar__0 x = casadi__IMatrix__isscalar__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isscalar__1" c_casadi__IMatrix__isscalar__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt
-casadi__IMatrix__isscalar__1
-  :: IMatrix -> Bool -> IO Bool
-casadi__IMatrix__isscalar__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isscalar__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isscalar__1 :: IMatrixClass a => a -> Bool -> IO Bool
-imatrix_isscalar__1 x = casadi__IMatrix__isscalar__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__issquare" c_casadi__IMatrix__issquare
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__issquare
-  :: IMatrix -> IO Bool
-casadi__IMatrix__issquare x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__issquare errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_issquare :: IMatrixClass a => a -> IO Bool
-imatrix_issquare x = casadi__IMatrix__issquare (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__istril" c_casadi__IMatrix__istril
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__istril
-  :: IMatrix -> IO Bool
-casadi__IMatrix__istril x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__istril errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_istril :: IMatrixClass a => a -> IO Bool
-imatrix_istril x = casadi__IMatrix__istril (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__istriu" c_casadi__IMatrix__istriu
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__istriu
-  :: IMatrix -> IO Bool
-casadi__IMatrix__istriu x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__istriu errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_istriu :: IMatrixClass a => a -> IO Bool
-imatrix_istriu x = casadi__IMatrix__istriu (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__isvector" c_casadi__IMatrix__isvector
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__isvector
-  :: IMatrix -> IO Bool
-casadi__IMatrix__isvector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__isvector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_isvector :: IMatrixClass a => a -> IO Bool
-imatrix_isvector x = casadi__IMatrix__isvector (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__makeSparse__0" c_casadi__IMatrix__makeSparse__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__makeSparse__0
-  :: IMatrix -> IO ()
-casadi__IMatrix__makeSparse__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__makeSparse__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_makeSparse__0 :: IMatrixClass a => a -> IO ()
-imatrix_makeSparse__0 x = casadi__IMatrix__makeSparse__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__makeSparse__1" c_casadi__IMatrix__makeSparse__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO ()
-casadi__IMatrix__makeSparse__1
-  :: IMatrix -> Double -> IO ()
-casadi__IMatrix__makeSparse__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__makeSparse__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_makeSparse__1 :: IMatrixClass a => a -> Double -> IO ()
-imatrix_makeSparse__1 x = casadi__IMatrix__makeSparse__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__matrix_matrix" c_casadi__IMatrix__matrix_matrix
-  :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__matrix_matrix
-  :: Int -> IMatrix -> IMatrix -> IO IMatrix
-casadi__IMatrix__matrix_matrix x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__matrix_matrix errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix
-imatrix_matrix_matrix = casadi__IMatrix__matrix_matrix
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__matrix_scalar" c_casadi__IMatrix__matrix_scalar
-  :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__matrix_scalar
-  :: Int -> IMatrix -> IMatrix -> IO IMatrix
-casadi__IMatrix__matrix_scalar x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__matrix_scalar errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix
-imatrix_matrix_scalar = casadi__IMatrix__matrix_scalar
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nan__0" c_casadi__IMatrix__nan__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi__IMatrix__nan__0
-  :: (Int, Int) -> IO IMatrix
-casadi__IMatrix__nan__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nan__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nan__0 :: (Int, Int) -> IO IMatrix
-imatrix_nan__0 = casadi__IMatrix__nan__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nan__1" c_casadi__IMatrix__nan__1
-  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
-casadi__IMatrix__nan__1
-  :: IO IMatrix
-casadi__IMatrix__nan__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nan__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nan__1 :: IO IMatrix
-imatrix_nan__1 = casadi__IMatrix__nan__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nan__2" c_casadi__IMatrix__nan__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__nan__2
-  :: Int -> IO IMatrix
-casadi__IMatrix__nan__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nan__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nan__2 :: Int -> IO IMatrix
-imatrix_nan__2 = casadi__IMatrix__nan__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nan__3" c_casadi__IMatrix__nan__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__nan__3
-  :: Int -> Int -> IO IMatrix
-casadi__IMatrix__nan__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nan__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nan__3 :: Int -> Int -> IO IMatrix
-imatrix_nan__3 = casadi__IMatrix__nan__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nan__4" c_casadi__IMatrix__nan__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi__IMatrix__nan__4
-  :: Sparsity -> IO IMatrix
-casadi__IMatrix__nan__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nan__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nan__4 :: Sparsity -> IO IMatrix
-imatrix_nan__4 = casadi__IMatrix__nan__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nnz" c_casadi__IMatrix__nnz
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__nnz
-  :: IMatrix -> IO Int
-casadi__IMatrix__nnz x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nnz errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nnz :: IMatrixClass a => a -> IO Int
-imatrix_nnz x = casadi__IMatrix__nnz (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nonzeros" c_casadi__IMatrix__nonzeros
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CDouble))
-casadi__IMatrix__nonzeros
-  :: IMatrix -> IO (Vector Double)
-casadi__IMatrix__nonzeros x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nonzeros errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nonzeros :: IMatrixClass a => a -> IO (Vector Double)
-imatrix_nonzeros x = casadi__IMatrix__nonzeros (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__nonzeros_int" c_casadi__IMatrix__nonzeros_int
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt))
-casadi__IMatrix__nonzeros_int
-  :: IMatrix -> IO (Vector Int)
-casadi__IMatrix__nonzeros_int x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__nonzeros_int errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_nonzeros_int :: IMatrixClass a => a -> IO (Vector Int)
-imatrix_nonzeros_int x = casadi__IMatrix__nonzeros_int (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__numel__0" c_casadi__IMatrix__numel__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt
-casadi__IMatrix__numel__0
-  :: IMatrix -> Int -> IO Int
-casadi__IMatrix__numel__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__numel__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_numel__0 :: IMatrixClass a => a -> Int -> IO Int
-imatrix_numel__0 x = casadi__IMatrix__numel__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__numel__1" c_casadi__IMatrix__numel__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__numel__1
-  :: IMatrix -> IO Int
-casadi__IMatrix__numel__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__numel__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_numel__1 :: IMatrixClass a => a -> IO Int
-imatrix_numel__1 x = casadi__IMatrix__numel__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__ones__0" c_casadi__IMatrix__ones__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi__IMatrix__ones__0
-  :: (Int, Int) -> IO IMatrix
-casadi__IMatrix__ones__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__ones__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_ones__0 :: (Int, Int) -> IO IMatrix
-imatrix_ones__0 = casadi__IMatrix__ones__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__ones__1" c_casadi__IMatrix__ones__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi__IMatrix__ones__1
-  :: Sparsity -> IO IMatrix
-casadi__IMatrix__ones__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__ones__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_ones__1 :: Sparsity -> IO IMatrix
-imatrix_ones__1 = casadi__IMatrix__ones__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__ones__2" c_casadi__IMatrix__ones__2
-  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
-casadi__IMatrix__ones__2
-  :: IO IMatrix
-casadi__IMatrix__ones__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__ones__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_ones__2 :: IO IMatrix
-imatrix_ones__2 = casadi__IMatrix__ones__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__ones__3" c_casadi__IMatrix__ones__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__ones__3
-  :: Int -> IO IMatrix
-casadi__IMatrix__ones__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__ones__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_ones__3 :: Int -> IO IMatrix
-imatrix_ones__3 = casadi__IMatrix__ones__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__ones__4" c_casadi__IMatrix__ones__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__ones__4
-  :: Int -> Int -> IO IMatrix
-casadi__IMatrix__ones__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__ones__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_ones__4 :: Int -> Int -> IO IMatrix
-imatrix_ones__4 = casadi__IMatrix__ones__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__operator_plus" c_casadi__IMatrix__operator_plus
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__operator_plus
-  :: IMatrix -> IO IMatrix
-casadi__IMatrix__operator_plus x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__operator_plus errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_operator_plus :: IMatrixClass a => a -> IO IMatrix
-imatrix_operator_plus x = casadi__IMatrix__operator_plus (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__operator_minus" c_casadi__IMatrix__operator_minus
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__operator_minus
-  :: IMatrix -> IO IMatrix
-casadi__IMatrix__operator_minus x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__operator_minus errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_operator_minus :: IMatrixClass a => a -> IO IMatrix
-imatrix_operator_minus x = casadi__IMatrix__operator_minus (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__printDense" c_casadi__IMatrix__printDense
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__printDense
-  :: IMatrix -> IO ()
-casadi__IMatrix__printDense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__printDense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_printDense :: IMatrixClass a => a -> IO ()
-imatrix_printDense x = casadi__IMatrix__printDense (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__printScalar" c_casadi__IMatrix__printScalar
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__printScalar
-  :: IMatrix -> IO ()
-casadi__IMatrix__printScalar x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__printScalar errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_printScalar :: IMatrixClass a => a -> IO ()
-imatrix_printScalar x = casadi__IMatrix__printScalar (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__printSparse" c_casadi__IMatrix__printSparse
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__printSparse
-  :: IMatrix -> IO ()
-casadi__IMatrix__printSparse x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__printSparse errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_printSparse :: IMatrixClass a => a -> IO ()
-imatrix_printSparse x = casadi__IMatrix__printSparse (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__printSplit" c_casadi__IMatrix__printSplit
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO ()
-casadi__IMatrix__printSplit
-  :: IMatrix -> Vector String -> Vector String -> IO ()
-casadi__IMatrix__printSplit x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__printSplit errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_printSplit :: IMatrixClass a => a -> Vector String -> Vector String -> IO ()
-imatrix_printSplit x = casadi__IMatrix__printSplit (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__printVector" c_casadi__IMatrix__printVector
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__printVector
-  :: IMatrix -> IO ()
-casadi__IMatrix__printVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__printVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_printVector :: IMatrixClass a => a -> IO ()
-imatrix_printVector x = casadi__IMatrix__printVector (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__printme" c_casadi__IMatrix__printme
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__printme
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi__IMatrix__printme x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__printme errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_printme :: IMatrixClass a => a -> IMatrix -> IO IMatrix
-imatrix_printme x = casadi__IMatrix__printme (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__remove" c_casadi__IMatrix__remove
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__IMatrix__remove
-  :: IMatrix -> Vector Int -> Vector Int -> IO ()
-casadi__IMatrix__remove x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__remove errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_remove :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
-imatrix_remove x = casadi__IMatrix__remove (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__reserve__0" c_casadi__IMatrix__reserve__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO ()
-casadi__IMatrix__reserve__0
-  :: IMatrix -> Int -> Int -> IO ()
-casadi__IMatrix__reserve__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__reserve__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_reserve__0 :: IMatrixClass a => a -> Int -> Int -> IO ()
-imatrix_reserve__0 x = casadi__IMatrix__reserve__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__reserve__1" c_casadi__IMatrix__reserve__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO ()
-casadi__IMatrix__reserve__1
-  :: IMatrix -> Int -> IO ()
-casadi__IMatrix__reserve__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__reserve__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_reserve__1 :: IMatrixClass a => a -> Int -> IO ()
-imatrix_reserve__1 x = casadi__IMatrix__reserve__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__resetInput" c_casadi__IMatrix__resetInput
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__resetInput
-  :: IMatrix -> IO ()
-casadi__IMatrix__resetInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__resetInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_resetInput :: IMatrixClass a => a -> IO ()
-imatrix_resetInput x = casadi__IMatrix__resetInput (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__resize" c_casadi__IMatrix__resize
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO ()
-casadi__IMatrix__resize
-  :: IMatrix -> Int -> Int -> IO ()
-casadi__IMatrix__resize x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__resize errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_resize :: IMatrixClass a => a -> Int -> Int -> IO ()
-imatrix_resize x = casadi__IMatrix__resize (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__row" c_casadi__IMatrix__row
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt
-casadi__IMatrix__row
-  :: IMatrix -> Int -> IO Int
-casadi__IMatrix__row x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__row errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_row :: IMatrixClass a => a -> Int -> IO Int
-imatrix_row x = casadi__IMatrix__row (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sanityCheck__0" c_casadi__IMatrix__sanityCheck__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__sanityCheck__0
-  :: IMatrix -> IO ()
-casadi__IMatrix__sanityCheck__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sanityCheck__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sanityCheck__0 :: IMatrixClass a => a -> IO ()
-imatrix_sanityCheck__0 x = casadi__IMatrix__sanityCheck__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sanityCheck__1" c_casadi__IMatrix__sanityCheck__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO ()
-casadi__IMatrix__sanityCheck__1
-  :: IMatrix -> Bool -> IO ()
-casadi__IMatrix__sanityCheck__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sanityCheck__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sanityCheck__1 :: IMatrixClass a => a -> Bool -> IO ()
-imatrix_sanityCheck__1 x = casadi__IMatrix__sanityCheck__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__scalar_matrix" c_casadi__IMatrix__scalar_matrix
-  :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__scalar_matrix
-  :: Int -> IMatrix -> IMatrix -> IO IMatrix
-casadi__IMatrix__scalar_matrix x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__scalar_matrix errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix
-imatrix_scalar_matrix = casadi__IMatrix__scalar_matrix
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__0" c_casadi__IMatrix__set__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__set__0
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__IMatrix__set__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO ()
-imatrix_set__0 x = casadi__IMatrix__set__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__1" c_casadi__IMatrix__set__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__IMatrix__set__1
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO ()
-casadi__IMatrix__set__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> IO ()
-imatrix_set__1 x = casadi__IMatrix__set__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__2" c_casadi__IMatrix__set__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__set__2
-  :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO ()
-casadi__IMatrix__set__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> IO ()
-imatrix_set__2 x = casadi__IMatrix__set__2 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__3" c_casadi__IMatrix__set__3
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__IMatrix__set__3
-  :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO ()
-casadi__IMatrix__set__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> IO ()
-imatrix_set__3 x = casadi__IMatrix__set__3 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__4" c_casadi__IMatrix__set__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__IMatrix__set__4
-  :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO ()
-casadi__IMatrix__set__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> IO ()
-imatrix_set__4 x = casadi__IMatrix__set__4 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__5" c_casadi__IMatrix__set__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__set__5
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO ()
-casadi__IMatrix__set__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO ()
-imatrix_set__5 x = casadi__IMatrix__set__5 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__6" c_casadi__IMatrix__set__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__IMatrix__set__6
-  :: IMatrix -> IMatrix -> Bool -> Slice -> IO ()
-casadi__IMatrix__set__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO ()
-imatrix_set__6 x = casadi__IMatrix__set__6 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__7" c_casadi__IMatrix__set__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__IMatrix__set__7
-  :: IMatrix -> Vector Double -> IO ()
-casadi__IMatrix__set__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__7 :: IMatrixClass a => a -> Vector Double -> IO ()
-imatrix_set__7 x = casadi__IMatrix__set__7 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__8" c_casadi__IMatrix__set__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__IMatrix__set__8
-  :: IMatrix -> Vector Double -> Bool -> IO ()
-casadi__IMatrix__set__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__8 :: IMatrixClass a => a -> Vector Double -> Bool -> IO ()
-imatrix_set__8 x = casadi__IMatrix__set__8 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__9" c_casadi__IMatrix__set__9
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO ()
-casadi__IMatrix__set__9
-  :: IMatrix -> Double -> IO ()
-casadi__IMatrix__set__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__9 :: IMatrixClass a => a -> Double -> IO ()
-imatrix_set__9 x = casadi__IMatrix__set__9 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__set__10" c_casadi__IMatrix__set__10
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__set__10
-  :: IMatrix -> IMatrix -> IO ()
-casadi__IMatrix__set__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__set__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_set__10 :: IMatrixClass a => a -> IMatrix -> IO ()
-imatrix_set__10 x = casadi__IMatrix__set__10 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__0" c_casadi__IMatrix__setEqualityCheckingDepth__0
-  :: Ptr (Ptr StdString) -> IO ()
-casadi__IMatrix__setEqualityCheckingDepth__0
-  :: IO ()
-casadi__IMatrix__setEqualityCheckingDepth__0  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setEqualityCheckingDepth__0 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setEqualityCheckingDepth__0 :: IO ()
-imatrix_setEqualityCheckingDepth__0 = casadi__IMatrix__setEqualityCheckingDepth__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__1" c_casadi__IMatrix__setEqualityCheckingDepth__1
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__IMatrix__setEqualityCheckingDepth__1
-  :: Int -> IO ()
-casadi__IMatrix__setEqualityCheckingDepth__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setEqualityCheckingDepth__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setEqualityCheckingDepth__1 :: Int -> IO ()
-imatrix_setEqualityCheckingDepth__1 = casadi__IMatrix__setEqualityCheckingDepth__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setNZ__0" c_casadi__IMatrix__setNZ__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__setNZ__0
-  :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO ()
-casadi__IMatrix__setNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO ()
-imatrix_setNZ__0 x = casadi__IMatrix__setNZ__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setNZ__1" c_casadi__IMatrix__setNZ__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO ()
-casadi__IMatrix__setNZ__1
-  :: IMatrix -> IMatrix -> Bool -> Slice -> IO ()
-casadi__IMatrix__setNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO ()
-imatrix_setNZ__1 x = casadi__IMatrix__setNZ__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setNZ__2" c_casadi__IMatrix__setNZ__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__IMatrix__setNZ__2
-  :: IMatrix -> Vector Double -> IO ()
-casadi__IMatrix__setNZ__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setNZ__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setNZ__2 :: IMatrixClass a => a -> Vector Double -> IO ()
-imatrix_setNZ__2 x = casadi__IMatrix__setNZ__2 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setNZ__3" c_casadi__IMatrix__setNZ__3
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO ()
-casadi__IMatrix__setNZ__3
-  :: IMatrix -> Double -> IO ()
-casadi__IMatrix__setNZ__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setNZ__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setNZ__3 :: IMatrixClass a => a -> Double -> IO ()
-imatrix_setNZ__3 x = casadi__IMatrix__setNZ__3 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setPrecision" c_casadi__IMatrix__setPrecision
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__IMatrix__setPrecision
-  :: Int -> IO ()
-casadi__IMatrix__setPrecision x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setPrecision errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setPrecision :: Int -> IO ()
-imatrix_setPrecision = casadi__IMatrix__setPrecision
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setScientific" c_casadi__IMatrix__setScientific
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__IMatrix__setScientific
-  :: Bool -> IO ()
-casadi__IMatrix__setScientific x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setScientific errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setScientific :: Bool -> IO ()
-imatrix_setScientific = casadi__IMatrix__setScientific
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setSym" c_casadi__IMatrix__setSym
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO ()
-casadi__IMatrix__setSym
-  :: IMatrix -> Vector Double -> IO ()
-casadi__IMatrix__setSym x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setSym errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setSym :: IMatrixClass a => a -> Vector Double -> IO ()
-imatrix_setSym x = casadi__IMatrix__setSym (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setValue__0" c_casadi__IMatrix__setValue__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> CInt -> IO ()
-casadi__IMatrix__setValue__0
-  :: IMatrix -> Double -> Int -> IO ()
-casadi__IMatrix__setValue__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setValue__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setValue__0 :: IMatrixClass a => a -> Double -> Int -> IO ()
-imatrix_setValue__0 x = casadi__IMatrix__setValue__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setValue__1" c_casadi__IMatrix__setValue__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO ()
-casadi__IMatrix__setValue__1
-  :: IMatrix -> Double -> IO ()
-casadi__IMatrix__setValue__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setValue__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setValue__1 :: IMatrixClass a => a -> Double -> IO ()
-imatrix_setValue__1 x = casadi__IMatrix__setValue__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setWidth" c_casadi__IMatrix__setWidth
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__IMatrix__setWidth
-  :: Int -> IO ()
-casadi__IMatrix__setWidth x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setWidth errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setWidth :: Int -> IO ()
-imatrix_setWidth = casadi__IMatrix__setWidth
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__setZero" c_casadi__IMatrix__setZero
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO ()
-casadi__IMatrix__setZero
-  :: IMatrix -> IO ()
-casadi__IMatrix__setZero x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__setZero errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_setZero :: IMatrixClass a => a -> IO ()
-imatrix_setZero x = casadi__IMatrix__setZero (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__shape__0" c_casadi__IMatrix__shape__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt
-casadi__IMatrix__shape__0
-  :: IMatrix -> Int -> IO Int
-casadi__IMatrix__shape__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__shape__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_shape__0 :: IMatrixClass a => a -> Int -> IO Int
-imatrix_shape__0 x = casadi__IMatrix__shape__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__shape__1" c_casadi__IMatrix__shape__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdPair CInt CInt))
-casadi__IMatrix__shape__1
-  :: IMatrix -> IO (Int, Int)
-casadi__IMatrix__shape__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__shape__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_shape__1 :: IMatrixClass a => a -> IO (Int, Int)
-imatrix_shape__1 x = casadi__IMatrix__shape__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__size" c_casadi__IMatrix__size
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__size
-  :: IMatrix -> IO Int
-casadi__IMatrix__size x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__size errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_size :: IMatrixClass a => a -> IO Int
-imatrix_size x = casadi__IMatrix__size (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__size1" c_casadi__IMatrix__size1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__size1
-  :: IMatrix -> IO Int
-casadi__IMatrix__size1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__size1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_size1 :: IMatrixClass a => a -> IO Int
-imatrix_size1 x = casadi__IMatrix__size1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__size2" c_casadi__IMatrix__size2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__size2
-  :: IMatrix -> IO Int
-casadi__IMatrix__size2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__size2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_size2 :: IMatrixClass a => a -> IO Int
-imatrix_size2 x = casadi__IMatrix__size2 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sizeD" c_casadi__IMatrix__sizeD
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__sizeD
-  :: IMatrix -> IO Int
-casadi__IMatrix__sizeD x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sizeD errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sizeD :: IMatrixClass a => a -> IO Int
-imatrix_sizeD x = casadi__IMatrix__sizeD (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sizeL" c_casadi__IMatrix__sizeL
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__sizeL
-  :: IMatrix -> IO Int
-casadi__IMatrix__sizeL x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sizeL errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sizeL :: IMatrixClass a => a -> IO Int
-imatrix_sizeL x = casadi__IMatrix__sizeL (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sizeU" c_casadi__IMatrix__sizeU
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi__IMatrix__sizeU
-  :: IMatrix -> IO Int
-casadi__IMatrix__sizeU x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sizeU errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sizeU :: IMatrixClass a => a -> IO Int
-imatrix_sizeU x = casadi__IMatrix__sizeU (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sparse__0" c_casadi__IMatrix__sparse__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__sparse__0
-  :: Sparsity -> IMatrix -> IO IMatrix
-casadi__IMatrix__sparse__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sparse__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sparse__0 :: Sparsity -> IMatrix -> IO IMatrix
-imatrix_sparse__0 = casadi__IMatrix__sparse__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sparse__1" c_casadi__IMatrix__sparse__1
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi__IMatrix__sparse__1
-  :: (Int, Int) -> IO IMatrix
-casadi__IMatrix__sparse__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sparse__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sparse__1 :: (Int, Int) -> IO IMatrix
-imatrix_sparse__1 = casadi__IMatrix__sparse__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sparse__2" c_casadi__IMatrix__sparse__2
-  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
-casadi__IMatrix__sparse__2
-  :: IO IMatrix
-casadi__IMatrix__sparse__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sparse__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sparse__2 :: IO IMatrix
-imatrix_sparse__2 = casadi__IMatrix__sparse__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sparse__3" c_casadi__IMatrix__sparse__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__sparse__3
-  :: Int -> IO IMatrix
-casadi__IMatrix__sparse__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sparse__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sparse__3 :: Int -> IO IMatrix
-imatrix_sparse__3 = casadi__IMatrix__sparse__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sparse__4" c_casadi__IMatrix__sparse__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__sparse__4
-  :: Int -> Int -> IO IMatrix
-casadi__IMatrix__sparse__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sparse__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sparse__4 :: Int -> Int -> IO IMatrix
-imatrix_sparse__4 = casadi__IMatrix__sparse__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sparsity" c_casadi__IMatrix__sparsity
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity')
-casadi__IMatrix__sparsity
-  :: IMatrix -> IO Sparsity
-casadi__IMatrix__sparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sparsity :: IMatrixClass a => a -> IO Sparsity
-imatrix_sparsity x = casadi__IMatrix__sparsity (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__0" c_casadi__IMatrix__sym__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-casadi__IMatrix__sym__0
-  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix))
-casadi__IMatrix__sym__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix))
-imatrix_sym__0 = casadi__IMatrix__sym__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__1" c_casadi__IMatrix__sym__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-casadi__IMatrix__sym__1
-  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix))
-casadi__IMatrix__sym__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix))
-imatrix_sym__1 = casadi__IMatrix__sym__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__2" c_casadi__IMatrix__sym__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi__IMatrix__sym__2
-  :: String -> Int -> Int -> Int -> IO (Vector IMatrix)
-casadi__IMatrix__sym__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector IMatrix)
-imatrix_sym__2 = casadi__IMatrix__sym__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__3" c_casadi__IMatrix__sym__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi__IMatrix__sym__3
-  :: String -> Sparsity -> Int -> IO (Vector IMatrix)
-casadi__IMatrix__sym__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector IMatrix)
-imatrix_sym__3 = casadi__IMatrix__sym__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__4" c_casadi__IMatrix__sym__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi__IMatrix__sym__4
-  :: String -> Sparsity -> IO IMatrix
-casadi__IMatrix__sym__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__4 :: String -> Sparsity -> IO IMatrix
-imatrix_sym__4 = casadi__IMatrix__sym__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__5" c_casadi__IMatrix__sym__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi__IMatrix__sym__5
-  :: String -> (Int, Int) -> IO IMatrix
-casadi__IMatrix__sym__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__5 :: String -> (Int, Int) -> IO IMatrix
-imatrix_sym__5 = casadi__IMatrix__sym__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__6" c_casadi__IMatrix__sym__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr IMatrix')
-casadi__IMatrix__sym__6
-  :: String -> IO IMatrix
-casadi__IMatrix__sym__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__6 :: String -> IO IMatrix
-imatrix_sym__6 = casadi__IMatrix__sym__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__7" c_casadi__IMatrix__sym__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__sym__7
-  :: String -> Int -> IO IMatrix
-casadi__IMatrix__sym__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__7 :: String -> Int -> IO IMatrix
-imatrix_sym__7 = casadi__IMatrix__sym__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__sym__8" c_casadi__IMatrix__sym__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__sym__8
-  :: String -> Int -> Int -> IO IMatrix
-casadi__IMatrix__sym__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__sym__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_sym__8 :: String -> Int -> Int -> IO IMatrix
-imatrix_sym__8 = casadi__IMatrix__sym__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__toSlice__0" c_casadi__IMatrix__toSlice__0
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Slice')
-casadi__IMatrix__toSlice__0
-  :: IMatrix -> IO Slice
-casadi__IMatrix__toSlice__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__toSlice__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_toSlice__0 :: IMatrixClass a => a -> IO Slice
-imatrix_toSlice__0 x = casadi__IMatrix__toSlice__0 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__toSlice__1" c_casadi__IMatrix__toSlice__1
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr Slice')
-casadi__IMatrix__toSlice__1
-  :: IMatrix -> Bool -> IO Slice
-casadi__IMatrix__toSlice__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__toSlice__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_toSlice__1 :: IMatrixClass a => a -> Bool -> IO Slice
-imatrix_toSlice__1 x = casadi__IMatrix__toSlice__1 (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__triplet__0" c_casadi__IMatrix__triplet__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi__IMatrix__triplet__0
-  :: Vector Int -> Vector Int -> IMatrix -> (Int, Int) -> IO IMatrix
-casadi__IMatrix__triplet__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__triplet__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_triplet__0 :: Vector Int -> Vector Int -> IMatrix -> (Int, Int) -> IO IMatrix
-imatrix_triplet__0 = casadi__IMatrix__triplet__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__triplet__1" c_casadi__IMatrix__triplet__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__triplet__1
-  :: Vector Int -> Vector Int -> IMatrix -> Int -> Int -> IO IMatrix
-casadi__IMatrix__triplet__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_triplet__1 :: Vector Int -> Vector Int -> IMatrix -> Int -> Int -> IO IMatrix
-imatrix_triplet__1 = casadi__IMatrix__triplet__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__triplet__2" c_casadi__IMatrix__triplet__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__triplet__2
-  :: Vector Int -> Vector Int -> IMatrix -> IO IMatrix
-casadi__IMatrix__triplet__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__triplet__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_triplet__2 :: Vector Int -> Vector Int -> IMatrix -> IO IMatrix
-imatrix_triplet__2 = casadi__IMatrix__triplet__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__unary" c_casadi__IMatrix__unary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi__IMatrix__unary
-  :: Int -> IMatrix -> IO IMatrix
-casadi__IMatrix__unary x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__unary errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_unary :: Int -> IMatrix -> IO IMatrix
-imatrix_unary = casadi__IMatrix__unary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__zeros__0" c_casadi__IMatrix__zeros__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi__IMatrix__zeros__0
-  :: (Int, Int) -> IO IMatrix
-casadi__IMatrix__zeros__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__zeros__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_zeros__0 :: (Int, Int) -> IO IMatrix
-imatrix_zeros__0 = casadi__IMatrix__zeros__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__zeros__1" c_casadi__IMatrix__zeros__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi__IMatrix__zeros__1
-  :: Sparsity -> IO IMatrix
-casadi__IMatrix__zeros__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__zeros__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_zeros__1 :: Sparsity -> IO IMatrix
-imatrix_zeros__1 = casadi__IMatrix__zeros__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__zeros__2" c_casadi__IMatrix__zeros__2
-  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
-casadi__IMatrix__zeros__2
-  :: IO IMatrix
-casadi__IMatrix__zeros__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__zeros__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_zeros__2 :: IO IMatrix
-imatrix_zeros__2 = casadi__IMatrix__zeros__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__zeros__3" c_casadi__IMatrix__zeros__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__zeros__3
-  :: Int -> IO IMatrix
-casadi__IMatrix__zeros__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__zeros__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_zeros__3 :: Int -> IO IMatrix
-imatrix_zeros__3 = casadi__IMatrix__zeros__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__zeros__4" c_casadi__IMatrix__zeros__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi__IMatrix__zeros__4
-  :: Int -> Int -> IO IMatrix
-casadi__IMatrix__zeros__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__zeros__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_zeros__4 :: Int -> Int -> IO IMatrix
-imatrix_zeros__4 = casadi__IMatrix__zeros__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getRepresentation" c_casadi__IMatrix__getRepresentation
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString)
-casadi__IMatrix__getRepresentation
-  :: IMatrix -> IO String
-casadi__IMatrix__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getRepresentation :: IMatrixClass a => a -> IO String
-imatrix_getRepresentation x = casadi__IMatrix__getRepresentation (castIMatrix x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IMatrix__getDescription" c_casadi__IMatrix__getDescription
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString)
-casadi__IMatrix__getDescription
-  :: IMatrix -> IO String
-casadi__IMatrix__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IMatrix__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-imatrix_getDescription :: IMatrixClass a => a -> IO String
-imatrix_getDescription x = casadi__IMatrix__getDescription (castIMatrix x)
-
diff --git a/Casadi/Core/Classes/IOInterfaceFunction.hs b/Casadi/Core/Classes/IOInterfaceFunction.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/IOInterfaceFunction.hs
+++ /dev/null
@@ -1,432 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.IOInterfaceFunction
-       (
-         IOInterfaceFunction,
-         IOInterfaceFunctionClass(..),
-         ioInterfaceFunction_getInput__0,
-         ioInterfaceFunction_getInput__1,
-         ioInterfaceFunction_getInput__2,
-         ioInterfaceFunction_getOutput__0,
-         ioInterfaceFunction_getOutput__1,
-         ioInterfaceFunction_getOutput__2,
-         ioInterfaceFunction_setInputNZ__0,
-         ioInterfaceFunction_setInputNZ__1,
-         ioInterfaceFunction_setInputNZ__2,
-         ioInterfaceFunction_setInput__0,
-         ioInterfaceFunction_setInput__1,
-         ioInterfaceFunction_setInput__2,
-         ioInterfaceFunction_setOutputNZ__0,
-         ioInterfaceFunction_setOutputNZ__1,
-         ioInterfaceFunction_setOutputNZ__2,
-         ioInterfaceFunction_setOutput__0,
-         ioInterfaceFunction_setOutput__1,
-         ioInterfaceFunction_setOutput__2,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getInput__0" c_casadi__IOInterface_casadi__Function___getInput__0
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix')
-casadi__IOInterface_casadi__Function___getInput__0
-  :: IOInterfaceFunction -> String -> IO DMatrix
-casadi__IOInterface_casadi__Function___getInput__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___getInput__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_getInput__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
-ioInterfaceFunction_getInput__0 x = casadi__IOInterface_casadi__Function___getInput__0 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getInput__1" c_casadi__IOInterface_casadi__Function___getInput__1
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr DMatrix')
-casadi__IOInterface_casadi__Function___getInput__1
-  :: IOInterfaceFunction -> IO DMatrix
-casadi__IOInterface_casadi__Function___getInput__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___getInput__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_getInput__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix
-ioInterfaceFunction_getInput__1 x = casadi__IOInterface_casadi__Function___getInput__1 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getInput__2" c_casadi__IOInterface_casadi__Function___getInput__2
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix')
-casadi__IOInterface_casadi__Function___getInput__2
-  :: IOInterfaceFunction -> Int -> IO DMatrix
-casadi__IOInterface_casadi__Function___getInput__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___getInput__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_getInput__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
-ioInterfaceFunction_getInput__2 x = casadi__IOInterface_casadi__Function___getInput__2 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getOutput__0" c_casadi__IOInterface_casadi__Function___getOutput__0
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix')
-casadi__IOInterface_casadi__Function___getOutput__0
-  :: IOInterfaceFunction -> String -> IO DMatrix
-casadi__IOInterface_casadi__Function___getOutput__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___getOutput__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_getOutput__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
-ioInterfaceFunction_getOutput__0 x = casadi__IOInterface_casadi__Function___getOutput__0 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getOutput__1" c_casadi__IOInterface_casadi__Function___getOutput__1
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr DMatrix')
-casadi__IOInterface_casadi__Function___getOutput__1
-  :: IOInterfaceFunction -> IO DMatrix
-casadi__IOInterface_casadi__Function___getOutput__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___getOutput__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_getOutput__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix
-ioInterfaceFunction_getOutput__1 x = casadi__IOInterface_casadi__Function___getOutput__1 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getOutput__2" c_casadi__IOInterface_casadi__Function___getOutput__2
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix')
-casadi__IOInterface_casadi__Function___getOutput__2
-  :: IOInterfaceFunction -> Int -> IO DMatrix
-casadi__IOInterface_casadi__Function___getOutput__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___getOutput__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_getOutput__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
-ioInterfaceFunction_getOutput__2 x = casadi__IOInterface_casadi__Function___getOutput__2 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__0" c_casadi__IOInterface_casadi__Function___setInput__0
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString -> IO ()
-casadi__IOInterface_casadi__Function___setInput__0
-  :: IOInterfaceFunction -> DMatrix -> String -> IO ()
-casadi__IOInterface_casadi__Function___setInput__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setInput__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setInput__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
-ioInterfaceFunction_setInput__0 x = casadi__IOInterface_casadi__Function___setInput__0 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__1" c_casadi__IOInterface_casadi__Function___setInput__1
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO ()
-casadi__IOInterface_casadi__Function___setInput__1
-  :: IOInterfaceFunction -> DMatrix -> IO ()
-casadi__IOInterface_casadi__Function___setInput__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setInput__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setInput__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
-ioInterfaceFunction_setInput__1 x = casadi__IOInterface_casadi__Function___setInput__1 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__2" c_casadi__IOInterface_casadi__Function___setInput__2
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO ()
-casadi__IOInterface_casadi__Function___setInput__2
-  :: IOInterfaceFunction -> DMatrix -> Int -> IO ()
-casadi__IOInterface_casadi__Function___setInput__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setInput__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setInput__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
-ioInterfaceFunction_setInput__2 x = casadi__IOInterface_casadi__Function___setInput__2 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInputNZ__0" c_casadi__IOInterface_casadi__Function___setInputNZ__0
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString -> IO ()
-casadi__IOInterface_casadi__Function___setInputNZ__0
-  :: IOInterfaceFunction -> DMatrix -> String -> IO ()
-casadi__IOInterface_casadi__Function___setInputNZ__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setInputNZ__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setInputNZ__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
-ioInterfaceFunction_setInputNZ__0 x = casadi__IOInterface_casadi__Function___setInputNZ__0 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInputNZ__1" c_casadi__IOInterface_casadi__Function___setInputNZ__1
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO ()
-casadi__IOInterface_casadi__Function___setInputNZ__1
-  :: IOInterfaceFunction -> DMatrix -> IO ()
-casadi__IOInterface_casadi__Function___setInputNZ__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setInputNZ__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setInputNZ__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
-ioInterfaceFunction_setInputNZ__1 x = casadi__IOInterface_casadi__Function___setInputNZ__1 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInputNZ__2" c_casadi__IOInterface_casadi__Function___setInputNZ__2
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO ()
-casadi__IOInterface_casadi__Function___setInputNZ__2
-  :: IOInterfaceFunction -> DMatrix -> Int -> IO ()
-casadi__IOInterface_casadi__Function___setInputNZ__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setInputNZ__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setInputNZ__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
-ioInterfaceFunction_setInputNZ__2 x = casadi__IOInterface_casadi__Function___setInputNZ__2 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__0" c_casadi__IOInterface_casadi__Function___setOutput__0
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString -> IO ()
-casadi__IOInterface_casadi__Function___setOutput__0
-  :: IOInterfaceFunction -> DMatrix -> String -> IO ()
-casadi__IOInterface_casadi__Function___setOutput__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setOutput__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setOutput__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
-ioInterfaceFunction_setOutput__0 x = casadi__IOInterface_casadi__Function___setOutput__0 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__1" c_casadi__IOInterface_casadi__Function___setOutput__1
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO ()
-casadi__IOInterface_casadi__Function___setOutput__1
-  :: IOInterfaceFunction -> DMatrix -> IO ()
-casadi__IOInterface_casadi__Function___setOutput__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setOutput__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setOutput__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
-ioInterfaceFunction_setOutput__1 x = casadi__IOInterface_casadi__Function___setOutput__1 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__2" c_casadi__IOInterface_casadi__Function___setOutput__2
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO ()
-casadi__IOInterface_casadi__Function___setOutput__2
-  :: IOInterfaceFunction -> DMatrix -> Int -> IO ()
-casadi__IOInterface_casadi__Function___setOutput__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setOutput__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setOutput__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
-ioInterfaceFunction_setOutput__2 x = casadi__IOInterface_casadi__Function___setOutput__2 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutputNZ__0" c_casadi__IOInterface_casadi__Function___setOutputNZ__0
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString -> IO ()
-casadi__IOInterface_casadi__Function___setOutputNZ__0
-  :: IOInterfaceFunction -> DMatrix -> String -> IO ()
-casadi__IOInterface_casadi__Function___setOutputNZ__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setOutputNZ__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setOutputNZ__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
-ioInterfaceFunction_setOutputNZ__0 x = casadi__IOInterface_casadi__Function___setOutputNZ__0 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutputNZ__1" c_casadi__IOInterface_casadi__Function___setOutputNZ__1
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO ()
-casadi__IOInterface_casadi__Function___setOutputNZ__1
-  :: IOInterfaceFunction -> DMatrix -> IO ()
-casadi__IOInterface_casadi__Function___setOutputNZ__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setOutputNZ__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setOutputNZ__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
-ioInterfaceFunction_setOutputNZ__1 x = casadi__IOInterface_casadi__Function___setOutputNZ__1 (castIOInterfaceFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutputNZ__2" c_casadi__IOInterface_casadi__Function___setOutputNZ__2
-  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO ()
-casadi__IOInterface_casadi__Function___setOutputNZ__2
-  :: IOInterfaceFunction -> DMatrix -> Int -> IO ()
-casadi__IOInterface_casadi__Function___setOutputNZ__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IOInterface_casadi__Function___setOutputNZ__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ioInterfaceFunction_setOutputNZ__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
-ioInterfaceFunction_setOutputNZ__2 x = casadi__IOInterface_casadi__Function___setOutputNZ__2 (castIOInterfaceFunction x)
-
diff --git a/Casadi/Core/Classes/ImplicitFunction.hs b/Casadi/Core/Classes/ImplicitFunction.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/ImplicitFunction.hs
+++ /dev/null
@@ -1,224 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.ImplicitFunction
-       (
-         ImplicitFunction,
-         ImplicitFunctionClass(..),
-         implicitFunction__0,
-         implicitFunction__1,
-         implicitFunction__2,
-         implicitFunction_doc,
-         implicitFunction_getF,
-         implicitFunction_getJac,
-         implicitFunction_getLinsol,
-         implicitFunction_hasPlugin,
-         implicitFunction_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__0" c_casadi__ImplicitFunction__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr ImplicitFunction')
-casadi__ImplicitFunction__CONSTRUCTOR__0
-  :: String -> String -> Function -> IO ImplicitFunction
-casadi__ImplicitFunction__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction__0 :: String -> String -> Function -> IO ImplicitFunction
-implicitFunction__0 = casadi__ImplicitFunction__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__1" c_casadi__ImplicitFunction__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ImplicitFunction')
-casadi__ImplicitFunction__CONSTRUCTOR__1
-  :: String -> String -> Function -> M.Map String GenericType -> IO ImplicitFunction
-casadi__ImplicitFunction__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction__1 :: String -> String -> Function -> M.Map String GenericType -> IO ImplicitFunction
-implicitFunction__1 = casadi__ImplicitFunction__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__2" c_casadi__ImplicitFunction__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr ImplicitFunction')
-casadi__ImplicitFunction__CONSTRUCTOR__2
-  :: IO ImplicitFunction
-casadi__ImplicitFunction__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction__2 :: IO ImplicitFunction
-implicitFunction__2 = casadi__ImplicitFunction__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__doc" c_casadi__ImplicitFunction__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__ImplicitFunction__doc
-  :: String -> IO String
-casadi__ImplicitFunction__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction_doc :: String -> IO String
-implicitFunction_doc = casadi__ImplicitFunction__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__getF" c_casadi__ImplicitFunction__getF
-  :: Ptr (Ptr StdString) -> Ptr ImplicitFunction' -> IO (Ptr Function')
-casadi__ImplicitFunction__getF
-  :: ImplicitFunction -> IO Function
-casadi__ImplicitFunction__getF x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__getF errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction_getF :: ImplicitFunctionClass a => a -> IO Function
-implicitFunction_getF x = casadi__ImplicitFunction__getF (castImplicitFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__getJac" c_casadi__ImplicitFunction__getJac
-  :: Ptr (Ptr StdString) -> Ptr ImplicitFunction' -> IO (Ptr Function')
-casadi__ImplicitFunction__getJac
-  :: ImplicitFunction -> IO Function
-casadi__ImplicitFunction__getJac x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__getJac errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction_getJac :: ImplicitFunctionClass a => a -> IO Function
-implicitFunction_getJac x = casadi__ImplicitFunction__getJac (castImplicitFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__getLinsol" c_casadi__ImplicitFunction__getLinsol
-  :: Ptr (Ptr StdString) -> Ptr ImplicitFunction' -> IO (Ptr LinearSolver')
-casadi__ImplicitFunction__getLinsol
-  :: ImplicitFunction -> IO LinearSolver
-casadi__ImplicitFunction__getLinsol x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__getLinsol errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction_getLinsol :: ImplicitFunctionClass a => a -> IO LinearSolver
-implicitFunction_getLinsol x = casadi__ImplicitFunction__getLinsol (castImplicitFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__hasPlugin" c_casadi__ImplicitFunction__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__ImplicitFunction__hasPlugin
-  :: String -> IO Bool
-casadi__ImplicitFunction__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction_hasPlugin :: String -> IO Bool
-implicitFunction_hasPlugin = casadi__ImplicitFunction__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__ImplicitFunction__loadPlugin" c_casadi__ImplicitFunction__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__ImplicitFunction__loadPlugin
-  :: String -> IO ()
-casadi__ImplicitFunction__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__ImplicitFunction__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-implicitFunction_loadPlugin :: String -> IO ()
-implicitFunction_loadPlugin = casadi__ImplicitFunction__loadPlugin
-
diff --git a/Casadi/Core/Classes/Integrator.hs b/Casadi/Core/Classes/Integrator.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/Integrator.hs
+++ /dev/null
@@ -1,496 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.Integrator
-       (
-         Integrator,
-         IntegratorClass(..),
-         integrator__0,
-         integrator__1,
-         integrator__2,
-         integrator__3,
-         integrator__4,
-         integrator__5,
-         integrator__6,
-         integrator__7,
-         integrator__8,
-         integrator_clone,
-         integrator_doc,
-         integrator_getAugmented,
-         integrator_getDAE,
-         integrator_hasPlugin,
-         integrator_integrate,
-         integrator_integrateB,
-         integrator_loadPlugin,
-         integrator_printStats,
-         integrator_reset,
-         integrator_resetB,
-         integrator_setStopTime,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__0" c_casadi__Integrator__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__0
-  :: String -> String -> M.Map String MX -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__0 :: String -> String -> M.Map String MX -> IO Integrator
-integrator__0 = casadi__Integrator__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__1" c_casadi__Integrator__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__1
-  :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__1 :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO Integrator
-integrator__1 = casadi__Integrator__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__2" c_casadi__Integrator__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__2
-  :: String -> String -> M.Map String SX -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__2 :: String -> String -> M.Map String SX -> IO Integrator
-integrator__2 = casadi__Integrator__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__3" c_casadi__Integrator__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__3
-  :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__3 :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO Integrator
-integrator__3 = casadi__Integrator__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__4" c_casadi__Integrator__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdPair (Ptr Function') (Ptr Function')) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__4
-  :: String -> String -> (Function, Function) -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__4 :: String -> String -> (Function, Function) -> IO Integrator
-integrator__4 = casadi__Integrator__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__5" c_casadi__Integrator__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdPair (Ptr Function') (Ptr Function')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__5
-  :: String -> String -> (Function, Function) -> M.Map String GenericType -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__5 :: String -> String -> (Function, Function) -> M.Map String GenericType -> IO Integrator
-integrator__5 = casadi__Integrator__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__6" c_casadi__Integrator__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__6
-  :: String -> String -> Function -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__6 :: String -> String -> Function -> IO Integrator
-integrator__6 = casadi__Integrator__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__7" c_casadi__Integrator__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__7
-  :: String -> String -> Function -> M.Map String GenericType -> IO Integrator
-casadi__Integrator__CONSTRUCTOR__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__7 :: String -> String -> Function -> M.Map String GenericType -> IO Integrator
-integrator__7 = casadi__Integrator__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__8" c_casadi__Integrator__CONSTRUCTOR__8
-  :: Ptr (Ptr StdString) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR__8
-  :: IO Integrator
-casadi__Integrator__CONSTRUCTOR__8  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR__8 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator__8 :: IO Integrator
-integrator__8 = casadi__Integrator__CONSTRUCTOR__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__clone" c_casadi__Integrator__clone
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> IO (Ptr Integrator')
-casadi__Integrator__clone
-  :: Integrator -> IO Integrator
-casadi__Integrator__clone x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__clone errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_clone :: IntegratorClass a => a -> IO Integrator
-integrator_clone x = casadi__Integrator__clone (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__doc" c_casadi__Integrator__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__Integrator__doc
-  :: String -> IO String
-casadi__Integrator__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_doc :: String -> IO String
-integrator_doc = casadi__Integrator__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__getAugmented" c_casadi__Integrator__getAugmented
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> CInt -> CInt -> IO (Ptr (StdPair (Ptr Function') (Ptr Function')))
-casadi__Integrator__getAugmented
-  :: Integrator -> Int -> Int -> IO (Function, Function)
-casadi__Integrator__getAugmented x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__getAugmented errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_getAugmented :: IntegratorClass a => a -> Int -> Int -> IO (Function, Function)
-integrator_getAugmented x = casadi__Integrator__getAugmented (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__getDAE" c_casadi__Integrator__getDAE
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> IO (Ptr Function')
-casadi__Integrator__getDAE
-  :: Integrator -> IO Function
-casadi__Integrator__getDAE x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__getDAE errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_getDAE :: IntegratorClass a => a -> IO Function
-integrator_getDAE x = casadi__Integrator__getDAE (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__hasPlugin" c_casadi__Integrator__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__Integrator__hasPlugin
-  :: String -> IO Bool
-casadi__Integrator__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_hasPlugin :: String -> IO Bool
-integrator_hasPlugin = casadi__Integrator__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__integrate" c_casadi__Integrator__integrate
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> CDouble -> IO ()
-casadi__Integrator__integrate
-  :: Integrator -> Double -> IO ()
-casadi__Integrator__integrate x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__integrate errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_integrate :: IntegratorClass a => a -> Double -> IO ()
-integrator_integrate x = casadi__Integrator__integrate (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__integrateB" c_casadi__Integrator__integrateB
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> CDouble -> IO ()
-casadi__Integrator__integrateB
-  :: Integrator -> Double -> IO ()
-casadi__Integrator__integrateB x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__integrateB errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_integrateB :: IntegratorClass a => a -> Double -> IO ()
-integrator_integrateB x = casadi__Integrator__integrateB (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__loadPlugin" c_casadi__Integrator__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__Integrator__loadPlugin
-  :: String -> IO ()
-casadi__Integrator__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_loadPlugin :: String -> IO ()
-integrator_loadPlugin = casadi__Integrator__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__printStats" c_casadi__Integrator__printStats
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> IO ()
-casadi__Integrator__printStats
-  :: Integrator -> IO ()
-casadi__Integrator__printStats x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__printStats errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_printStats :: IntegratorClass a => a -> IO ()
-integrator_printStats x = casadi__Integrator__printStats (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__reset" c_casadi__Integrator__reset
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> IO ()
-casadi__Integrator__reset
-  :: Integrator -> IO ()
-casadi__Integrator__reset x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__reset errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_reset :: IntegratorClass a => a -> IO ()
-integrator_reset x = casadi__Integrator__reset (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__resetB" c_casadi__Integrator__resetB
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> IO ()
-casadi__Integrator__resetB
-  :: Integrator -> IO ()
-casadi__Integrator__resetB x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__resetB errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_resetB :: IntegratorClass a => a -> IO ()
-integrator_resetB x = casadi__Integrator__resetB (castIntegrator x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__setStopTime" c_casadi__Integrator__setStopTime
-  :: Ptr (Ptr StdString) -> Ptr Integrator' -> CDouble -> IO ()
-casadi__Integrator__setStopTime
-  :: Integrator -> Double -> IO ()
-casadi__Integrator__setStopTime x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__setStopTime errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-integrator_setStopTime :: IntegratorClass a => a -> Double -> IO ()
-integrator_setStopTime x = casadi__Integrator__setStopTime (castIntegrator x)
-
diff --git a/Casadi/Core/Classes/IterationCallback.hs b/Casadi/Core/Classes/IterationCallback.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/IterationCallback.hs
+++ /dev/null
@@ -1,73 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.IterationCallback
-       (
-         IterationCallback,
-         IterationCallbackClass(..),
-         iterationCallback,
-         iterationCallback_operator_call,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__IterationCallback__CONSTRUCTOR" c_casadi__IterationCallback__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr IterationCallback')
-casadi__IterationCallback__CONSTRUCTOR
-  :: IO IterationCallback
-casadi__IterationCallback__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IterationCallback__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-iterationCallback :: IO IterationCallback
-iterationCallback = casadi__IterationCallback__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__IterationCallback__operator_call" c_casadi__IterationCallback__operator_call
-  :: Ptr (Ptr StdString) -> Ptr IterationCallback' -> Ptr Function' -> IO CInt
-casadi__IterationCallback__operator_call
-  :: IterationCallback -> Function -> IO Int
-casadi__IterationCallback__operator_call x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__IterationCallback__operator_call errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-iterationCallback_operator_call :: IterationCallbackClass a => a -> Function -> IO Int
-iterationCallback_operator_call x = casadi__IterationCallback__operator_call (castIterationCallback x)
-
diff --git a/Casadi/Core/Classes/KernelSum2D.hs b/Casadi/Core/Classes/KernelSum2D.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/KernelSum2D.hs
+++ /dev/null
@@ -1,102 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.KernelSum2D
-       (
-         KernelSum2D,
-         KernelSum2DClass(..),
-         kernelSum2D__0,
-         kernelSum2D__1,
-         kernelSum2D__2,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__KernelSum2D__CONSTRUCTOR__0" c_casadi__KernelSum2D__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr (StdPair CInt CInt) -> CDouble -> CInt -> IO (Ptr KernelSum2D')
-casadi__KernelSum2D__CONSTRUCTOR__0
-  :: String -> Function -> (Int, Int) -> Double -> Int -> IO KernelSum2D
-casadi__KernelSum2D__CONSTRUCTOR__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__KernelSum2D__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-kernelSum2D__0 :: String -> Function -> (Int, Int) -> Double -> Int -> IO KernelSum2D
-kernelSum2D__0 = casadi__KernelSum2D__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__KernelSum2D__CONSTRUCTOR__1" c_casadi__KernelSum2D__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr (StdPair CInt CInt) -> CDouble -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr KernelSum2D')
-casadi__KernelSum2D__CONSTRUCTOR__1
-  :: String -> Function -> (Int, Int) -> Double -> Int -> M.Map String GenericType -> IO KernelSum2D
-casadi__KernelSum2D__CONSTRUCTOR__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__KernelSum2D__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-kernelSum2D__1 :: String -> Function -> (Int, Int) -> Double -> Int -> M.Map String GenericType -> IO KernelSum2D
-kernelSum2D__1 = casadi__KernelSum2D__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__KernelSum2D__CONSTRUCTOR__2" c_casadi__KernelSum2D__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr KernelSum2D')
-casadi__KernelSum2D__CONSTRUCTOR__2
-  :: IO KernelSum2D
-casadi__KernelSum2D__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__KernelSum2D__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-kernelSum2D__2 :: IO KernelSum2D
-kernelSum2D__2 = casadi__KernelSum2D__CONSTRUCTOR__2
-
diff --git a/Casadi/Core/Classes/Library.hs b/Casadi/Core/Classes/Library.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/Library.hs
@@ -0,0 +1,144 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.Library
+       (
+         Library,
+         LibraryClass(..),
+         library__0,
+         library__1,
+         library__2,
+         library_has,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__Library__CONSTRUCTOR__0" c_casadi__Library__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr Compiler' -> IO (Ptr Library')
+
+casadi__Library__CONSTRUCTOR__0
+  :: Compiler -> IO Library
+casadi__Library__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Library__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+library__0 :: Compiler -> IO Library
+library__0 = casadi__Library__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Library__CONSTRUCTOR__1" c_casadi__Library__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr Library')
+
+casadi__Library__CONSTRUCTOR__1
+  :: String -> IO Library
+casadi__Library__CONSTRUCTOR__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Library__CONSTRUCTOR__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+library__1 :: String -> IO Library
+library__1 = casadi__Library__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Library__CONSTRUCTOR__2" c_casadi__Library__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> IO (Ptr Library')
+
+casadi__Library__CONSTRUCTOR__2
+  :: IO Library
+casadi__Library__CONSTRUCTOR__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Library__CONSTRUCTOR__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+library__2 :: IO Library
+library__2 = casadi__Library__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Library__has" c_casadi__Library__has
+  :: Ptr (Ptr StdString) -> Ptr Library' -> Ptr StdString -> IO CInt
+
+casadi__Library__has
+  :: Library -> String -> IO Bool
+casadi__Library__has x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Library__has errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+library_has :: LibraryClass a => a -> String -> IO Bool
+library_has x = casadi__Library__has (castLibrary x)
+
diff --git a/Casadi/Core/Classes/LinearSolver.hs b/Casadi/Core/Classes/LinearSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/LinearSolver.hs
+++ /dev/null
@@ -1,407 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.LinearSolver
-       (
-         LinearSolver,
-         LinearSolverClass(..),
-         linearSolver__0,
-         linearSolver__1,
-         linearSolver__2,
-         linearSolver__3,
-         linearSolver_doc,
-         linearSolver_getFactorizationSparsity__0,
-         linearSolver_getFactorizationSparsity__1,
-         linearSolver_getFactorization__0,
-         linearSolver_getFactorization__1,
-         linearSolver_hasPlugin,
-         linearSolver_loadPlugin,
-         linearSolver_prepare,
-         linearSolver_prepared,
-         linearSolver_solve__0,
-         linearSolver_solve__1,
-         linearSolver_solve__2,
-         linearSolver_solve__3,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__0" c_casadi__LinearSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr LinearSolver')
-casadi__LinearSolver__CONSTRUCTOR__0
-  :: String -> String -> Sparsity -> Int -> IO LinearSolver
-casadi__LinearSolver__CONSTRUCTOR__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver__0 :: String -> String -> Sparsity -> Int -> IO LinearSolver
-linearSolver__0 = casadi__LinearSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__1" c_casadi__LinearSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LinearSolver')
-casadi__LinearSolver__CONSTRUCTOR__1
-  :: String -> String -> Sparsity -> Int -> M.Map String GenericType -> IO LinearSolver
-casadi__LinearSolver__CONSTRUCTOR__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver__1 :: String -> String -> Sparsity -> Int -> M.Map String GenericType -> IO LinearSolver
-linearSolver__1 = casadi__LinearSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__2" c_casadi__LinearSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr LinearSolver')
-casadi__LinearSolver__CONSTRUCTOR__2
-  :: String -> String -> Sparsity -> IO LinearSolver
-casadi__LinearSolver__CONSTRUCTOR__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__CONSTRUCTOR__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver__2 :: String -> String -> Sparsity -> IO LinearSolver
-linearSolver__2 = casadi__LinearSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__3" c_casadi__LinearSolver__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LinearSolver')
-casadi__LinearSolver__CONSTRUCTOR__3
-  :: String -> String -> Sparsity -> M.Map String GenericType -> IO LinearSolver
-casadi__LinearSolver__CONSTRUCTOR__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver__3 :: String -> String -> Sparsity -> M.Map String GenericType -> IO LinearSolver
-linearSolver__3 = casadi__LinearSolver__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__doc" c_casadi__LinearSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__LinearSolver__doc
-  :: String -> IO String
-casadi__LinearSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_doc :: String -> IO String
-linearSolver_doc = casadi__LinearSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__getFactorization__0" c_casadi__LinearSolver__getFactorization__0
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> IO (Ptr DMatrix')
-casadi__LinearSolver__getFactorization__0
-  :: LinearSolver -> IO DMatrix
-casadi__LinearSolver__getFactorization__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__getFactorization__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_getFactorization__0 :: LinearSolverClass a => a -> IO DMatrix
-linearSolver_getFactorization__0 x = casadi__LinearSolver__getFactorization__0 (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__getFactorization__1" c_casadi__LinearSolver__getFactorization__1
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> CInt -> IO (Ptr DMatrix')
-casadi__LinearSolver__getFactorization__1
-  :: LinearSolver -> Bool -> IO DMatrix
-casadi__LinearSolver__getFactorization__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__getFactorization__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_getFactorization__1 :: LinearSolverClass a => a -> Bool -> IO DMatrix
-linearSolver_getFactorization__1 x = casadi__LinearSolver__getFactorization__1 (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__getFactorizationSparsity__0" c_casadi__LinearSolver__getFactorizationSparsity__0
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> IO (Ptr Sparsity')
-casadi__LinearSolver__getFactorizationSparsity__0
-  :: LinearSolver -> IO Sparsity
-casadi__LinearSolver__getFactorizationSparsity__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__getFactorizationSparsity__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_getFactorizationSparsity__0 :: LinearSolverClass a => a -> IO Sparsity
-linearSolver_getFactorizationSparsity__0 x = casadi__LinearSolver__getFactorizationSparsity__0 (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__getFactorizationSparsity__1" c_casadi__LinearSolver__getFactorizationSparsity__1
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> CInt -> IO (Ptr Sparsity')
-casadi__LinearSolver__getFactorizationSparsity__1
-  :: LinearSolver -> Bool -> IO Sparsity
-casadi__LinearSolver__getFactorizationSparsity__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__getFactorizationSparsity__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_getFactorizationSparsity__1 :: LinearSolverClass a => a -> Bool -> IO Sparsity
-linearSolver_getFactorizationSparsity__1 x = casadi__LinearSolver__getFactorizationSparsity__1 (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__hasPlugin" c_casadi__LinearSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__LinearSolver__hasPlugin
-  :: String -> IO Bool
-casadi__LinearSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_hasPlugin :: String -> IO Bool
-linearSolver_hasPlugin = casadi__LinearSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__loadPlugin" c_casadi__LinearSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__LinearSolver__loadPlugin
-  :: String -> IO ()
-casadi__LinearSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_loadPlugin :: String -> IO ()
-linearSolver_loadPlugin = casadi__LinearSolver__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__prepare" c_casadi__LinearSolver__prepare
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> IO ()
-casadi__LinearSolver__prepare
-  :: LinearSolver -> IO ()
-casadi__LinearSolver__prepare x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__prepare errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_prepare :: LinearSolverClass a => a -> IO ()
-linearSolver_prepare x = casadi__LinearSolver__prepare (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__prepared" c_casadi__LinearSolver__prepared
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> IO CInt
-casadi__LinearSolver__prepared
-  :: LinearSolver -> IO Bool
-casadi__LinearSolver__prepared x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__prepared errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_prepared :: LinearSolverClass a => a -> IO Bool
-linearSolver_prepared x = casadi__LinearSolver__prepared (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__solve__0" c_casadi__LinearSolver__solve__0
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi__LinearSolver__solve__0
-  :: LinearSolver -> MX -> MX -> IO MX
-casadi__LinearSolver__solve__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__solve__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_solve__0 :: LinearSolverClass a => a -> MX -> MX -> IO MX
-linearSolver_solve__0 x = casadi__LinearSolver__solve__0 (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__solve__1" c_casadi__LinearSolver__solve__1
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi__LinearSolver__solve__1
-  :: LinearSolver -> MX -> MX -> Bool -> IO MX
-casadi__LinearSolver__solve__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__solve__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_solve__1 :: LinearSolverClass a => a -> MX -> MX -> Bool -> IO MX
-linearSolver_solve__1 x = casadi__LinearSolver__solve__1 (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__solve__2" c_casadi__LinearSolver__solve__2
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> IO ()
-casadi__LinearSolver__solve__2
-  :: LinearSolver -> IO ()
-casadi__LinearSolver__solve__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__solve__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_solve__2 :: LinearSolverClass a => a -> IO ()
-linearSolver_solve__2 x = casadi__LinearSolver__solve__2 (castLinearSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LinearSolver__solve__3" c_casadi__LinearSolver__solve__3
-  :: Ptr (Ptr StdString) -> Ptr LinearSolver' -> CInt -> IO ()
-casadi__LinearSolver__solve__3
-  :: LinearSolver -> Bool -> IO ()
-casadi__LinearSolver__solve__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__solve__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-linearSolver_solve__3 :: LinearSolverClass a => a -> Bool -> IO ()
-linearSolver_solve__3 x = casadi__LinearSolver__solve__3 (castLinearSolver x)
-
diff --git a/Casadi/Core/Classes/LpSolver.hs b/Casadi/Core/Classes/LpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/LpSolver.hs
+++ /dev/null
@@ -1,161 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.LpSolver
-       (
-         LpSolver,
-         LpSolverClass(..),
-         lpSolver__0,
-         lpSolver__1,
-         lpSolver__2,
-         lpSolver_doc,
-         lpSolver_hasPlugin,
-         lpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR__0" c_casadi__LpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr LpSolver')
-casadi__LpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO LpSolver
-casadi__LpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lpSolver__0 :: String -> String -> M.Map String Sparsity -> IO LpSolver
-lpSolver__0 = casadi__LpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR__1" c_casadi__LpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LpSolver')
-casadi__LpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LpSolver
-casadi__LpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LpSolver
-lpSolver__1 = casadi__LpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR__2" c_casadi__LpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr LpSolver')
-casadi__LpSolver__CONSTRUCTOR__2
-  :: IO LpSolver
-casadi__LpSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LpSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lpSolver__2 :: IO LpSolver
-lpSolver__2 = casadi__LpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LpSolver__doc" c_casadi__LpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__LpSolver__doc
-  :: String -> IO String
-casadi__LpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lpSolver_doc :: String -> IO String
-lpSolver_doc = casadi__LpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LpSolver__hasPlugin" c_casadi__LpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__LpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__LpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lpSolver_hasPlugin :: String -> IO Bool
-lpSolver_hasPlugin = casadi__LpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LpSolver__loadPlugin" c_casadi__LpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__LpSolver__loadPlugin
-  :: String -> IO ()
-casadi__LpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lpSolver_loadPlugin :: String -> IO ()
-lpSolver_loadPlugin = casadi__LpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/LrDleSolver.hs b/Casadi/Core/Classes/LrDleSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/LrDleSolver.hs
+++ /dev/null
@@ -1,246 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.LrDleSolver
-       (
-         LrDleSolver,
-         LrDleSolverClass(..),
-         lrDleSolver__0,
-         lrDleSolver__1,
-         lrDleSolver__2,
-         lrDleSolver_clone,
-         lrDleSolver_doc,
-         lrDleSolver_getSparsity__0,
-         lrDleSolver_getSparsity__1,
-         lrDleSolver_hasPlugin,
-         lrDleSolver_loadPlugin,
-         lrDleSolver_printStats,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__CONSTRUCTOR__0" c_casadi__LrDleSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr LrDleSolver')
-casadi__LrDleSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO LrDleSolver
-casadi__LrDleSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver__0 :: String -> String -> M.Map String Sparsity -> IO LrDleSolver
-lrDleSolver__0 = casadi__LrDleSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__CONSTRUCTOR__1" c_casadi__LrDleSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LrDleSolver')
-casadi__LrDleSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LrDleSolver
-casadi__LrDleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LrDleSolver
-lrDleSolver__1 = casadi__LrDleSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__CONSTRUCTOR__2" c_casadi__LrDleSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr LrDleSolver')
-casadi__LrDleSolver__CONSTRUCTOR__2
-  :: IO LrDleSolver
-casadi__LrDleSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver__2 :: IO LrDleSolver
-lrDleSolver__2 = casadi__LrDleSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__clone" c_casadi__LrDleSolver__clone
-  :: Ptr (Ptr StdString) -> Ptr LrDleSolver' -> IO (Ptr LrDleSolver')
-casadi__LrDleSolver__clone
-  :: LrDleSolver -> IO LrDleSolver
-casadi__LrDleSolver__clone x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__clone errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver_clone :: LrDleSolverClass a => a -> IO LrDleSolver
-lrDleSolver_clone x = casadi__LrDleSolver__clone (castLrDleSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__doc" c_casadi__LrDleSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__LrDleSolver__doc
-  :: String -> IO String
-casadi__LrDleSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver_doc :: String -> IO String
-lrDleSolver_doc = casadi__LrDleSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__getSparsity__0" c_casadi__LrDleSolver__getSparsity__0
-  :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr Sparsity')
-casadi__LrDleSolver__getSparsity__0
-  :: M.Map String Sparsity -> IO Sparsity
-casadi__LrDleSolver__getSparsity__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__getSparsity__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver_getSparsity__0 :: M.Map String Sparsity -> IO Sparsity
-lrDleSolver_getSparsity__0 = casadi__LrDleSolver__getSparsity__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__getSparsity__1" c_casadi__LrDleSolver__getSparsity__1
-  :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__LrDleSolver__getSparsity__1
-  :: M.Map String Sparsity -> Vector Int -> IO Sparsity
-casadi__LrDleSolver__getSparsity__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__getSparsity__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver_getSparsity__1 :: M.Map String Sparsity -> Vector Int -> IO Sparsity
-lrDleSolver_getSparsity__1 = casadi__LrDleSolver__getSparsity__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__hasPlugin" c_casadi__LrDleSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__LrDleSolver__hasPlugin
-  :: String -> IO Bool
-casadi__LrDleSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver_hasPlugin :: String -> IO Bool
-lrDleSolver_hasPlugin = casadi__LrDleSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__loadPlugin" c_casadi__LrDleSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__LrDleSolver__loadPlugin
-  :: String -> IO ()
-casadi__LrDleSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver_loadPlugin :: String -> IO ()
-lrDleSolver_loadPlugin = casadi__LrDleSolver__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDleSolver__printStats" c_casadi__LrDleSolver__printStats
-  :: Ptr (Ptr StdString) -> Ptr LrDleSolver' -> IO ()
-casadi__LrDleSolver__printStats
-  :: LrDleSolver -> IO ()
-casadi__LrDleSolver__printStats x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDleSolver__printStats errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDleSolver_printStats :: LrDleSolverClass a => a -> IO ()
-lrDleSolver_printStats x = casadi__LrDleSolver__printStats (castLrDleSolver x)
-
diff --git a/Casadi/Core/Classes/LrDpleSolver.hs b/Casadi/Core/Classes/LrDpleSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/LrDpleSolver.hs
+++ /dev/null
@@ -1,203 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.LrDpleSolver
-       (
-         LrDpleSolver,
-         LrDpleSolverClass(..),
-         lrDpleSolver__0,
-         lrDpleSolver__1,
-         lrDpleSolver__2,
-         lrDpleSolver_clone,
-         lrDpleSolver_doc,
-         lrDpleSolver_hasPlugin,
-         lrDpleSolver_loadPlugin,
-         lrDpleSolver_printStats,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__CONSTRUCTOR__0" c_casadi__LrDpleSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr LrDpleSolver')
-casadi__LrDpleSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String (Vector Sparsity) -> IO LrDpleSolver
-casadi__LrDpleSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver__0 :: String -> String -> M.Map String (Vector Sparsity) -> IO LrDpleSolver
-lrDpleSolver__0 = casadi__LrDpleSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__CONSTRUCTOR__1" c_casadi__LrDpleSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LrDpleSolver')
-casadi__LrDpleSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO LrDpleSolver
-casadi__LrDpleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver__1 :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO LrDpleSolver
-lrDpleSolver__1 = casadi__LrDpleSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__CONSTRUCTOR__2" c_casadi__LrDpleSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr LrDpleSolver')
-casadi__LrDpleSolver__CONSTRUCTOR__2
-  :: IO LrDpleSolver
-casadi__LrDpleSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver__2 :: IO LrDpleSolver
-lrDpleSolver__2 = casadi__LrDpleSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__clone" c_casadi__LrDpleSolver__clone
-  :: Ptr (Ptr StdString) -> Ptr LrDpleSolver' -> IO (Ptr LrDpleSolver')
-casadi__LrDpleSolver__clone
-  :: LrDpleSolver -> IO LrDpleSolver
-casadi__LrDpleSolver__clone x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__clone errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver_clone :: LrDpleSolverClass a => a -> IO LrDpleSolver
-lrDpleSolver_clone x = casadi__LrDpleSolver__clone (castLrDpleSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__doc" c_casadi__LrDpleSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__LrDpleSolver__doc
-  :: String -> IO String
-casadi__LrDpleSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver_doc :: String -> IO String
-lrDpleSolver_doc = casadi__LrDpleSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__hasPlugin" c_casadi__LrDpleSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__LrDpleSolver__hasPlugin
-  :: String -> IO Bool
-casadi__LrDpleSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver_hasPlugin :: String -> IO Bool
-lrDpleSolver_hasPlugin = casadi__LrDpleSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__loadPlugin" c_casadi__LrDpleSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__LrDpleSolver__loadPlugin
-  :: String -> IO ()
-casadi__LrDpleSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver_loadPlugin :: String -> IO ()
-lrDpleSolver_loadPlugin = casadi__LrDpleSolver__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__LrDpleSolver__printStats" c_casadi__LrDpleSolver__printStats
-  :: Ptr (Ptr StdString) -> Ptr LrDpleSolver' -> IO ()
-casadi__LrDpleSolver__printStats
-  :: LrDpleSolver -> IO ()
-casadi__LrDpleSolver__printStats x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__LrDpleSolver__printStats errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-lrDpleSolver_printStats :: LrDpleSolverClass a => a -> IO ()
-lrDpleSolver_printStats x = casadi__LrDpleSolver__printStats (castLrDpleSolver x)
-
diff --git a/Casadi/Core/Classes/MX.hs b/Casadi/Core/Classes/MX.hs
--- a/Casadi/Core/Classes/MX.hs
+++ b/Casadi/Core/Classes/MX.hs
@@ -19,3442 +19,5236 @@
          mx__6,
          mx__7,
          mx___nonzero__,
-         mx_append,
-         mx_appendColumns,
-         mx_attachAssert__0,
-         mx_attachAssert__1,
-         mx_binary,
-         mx_colind,
-         mx_dimString,
-         mx_enlarge__0,
-         mx_enlarge__1,
-         mx_erase__0,
-         mx_erase__1,
-         mx_erase__2,
-         mx_erase__3,
-         mx_eye,
-         mx_find__0,
-         mx_find__1,
-         mx_getColind,
-         mx_getDep__0,
-         mx_getDep__1,
-         mx_getEqualityCheckingDepth,
-         mx_getEvaluationOutput,
-         mx_getFunction__0,
-         mx_getFunction__1,
-         mx_getMatrixValue,
-         mx_getNZ__0,
-         mx_getNZ__1,
-         mx_getName,
-         mx_getNdeps,
-         mx_getOp,
-         mx_getOutput__0,
-         mx_getOutput__1,
-         mx_getPrimitives,
-         mx_getRow,
-         mx_getSparsity,
-         mx_getTemp,
-         mx_getValue,
-         mx_get__0,
-         mx_get__1,
-         mx_get__2,
-         mx_get__3,
-         mx_get__4,
-         mx_get__5,
-         mx_get__6,
-         mx_hasDuplicates,
-         mx_inf__0,
-         mx_inf__1,
-         mx_inf__2,
-         mx_inf__3,
-         mx_inf__4,
-         mx_isBinary,
-         mx_isCommutative,
-         mx_isConstant,
-         mx_isEvaluation,
-         mx_isEvaluationOutput,
-         mx_isIdentity,
-         mx_isMinusOne,
-         mx_isMultiplication,
-         mx_isNorm,
-         mx_isOne,
-         mx_isOperation,
-         mx_isRegular,
-         mx_isSymbolic,
-         mx_isTranspose,
-         mx_isUnary,
-         mx_isValidInput,
-         mx_isZero,
-         mx_iscolumn,
-         mx_isdense,
-         mx_isempty__0,
-         mx_isempty__1,
-         mx_isrow,
-         mx_isscalar__0,
-         mx_isscalar__1,
-         mx_issquare,
-         mx_istril,
-         mx_istriu,
-         mx_isvector,
-         mx_joinPrimitives,
-         mx_lift,
-         mx_makeDense__0,
-         mx_makeDense__1,
-         mx_mapping,
-         mx_monitor,
-         mx_nOut,
-         mx_nan__0,
-         mx_nan__1,
-         mx_nan__2,
-         mx_nan__3,
-         mx_nan__4,
-         mx_nnz,
-         mx_numFunctions,
-         mx_numPrimitives,
-         mx_numel__0,
-         mx_numel__1,
-         mx_ones__0,
-         mx_ones__1,
-         mx_ones__2,
-         mx_ones__3,
-         mx_ones__4,
-         mx_operator_minus,
-         mx_printme,
-         mx_resetInput,
-         mx_row,
-         mx_setEqualityCheckingDepth__0,
-         mx_setEqualityCheckingDepth__1,
-         mx_setNZ__0,
-         mx_setNZ__1,
-         mx_setTemp,
-         mx_set__0,
-         mx_set__1,
-         mx_set__2,
-         mx_set__3,
-         mx_set__4,
-         mx_set__5,
-         mx_set__6,
-         mx_shape__0,
-         mx_shape__1,
-         mx_size,
-         mx_size1,
-         mx_size2,
-         mx_sizeD,
-         mx_sizeL,
-         mx_sizeU,
-         mx_sparse__0,
-         mx_sparse__1,
-         mx_sparse__2,
-         mx_sparse__3,
-         mx_sparse__4,
-         mx_sparsity,
-         mx_splitPrimitives,
-         mx_sym__0,
-         mx_sym__1,
-         mx_sym__2,
-         mx_sym__3,
-         mx_sym__4,
-         mx_sym__5,
-         mx_sym__6,
-         mx_sym__7,
-         mx_sym__8,
-         mx_unary,
-         mx_zeros__0,
-         mx_zeros__1,
-         mx_zeros__2,
-         mx_zeros__3,
-         mx_zeros__4,
-         mx_zz_project__0,
-         mx_zz_project__1,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__0" c_casadi__MX__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__0
-  :: DMatrix -> IO MX
-casadi__MX__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__0 :: DMatrix -> IO MX
-mx__0 = casadi__MX__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__1" c_casadi__MX__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__1
-  :: Vector Double -> IO MX
-casadi__MX__CONSTRUCTOR__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__1 :: Vector Double -> IO MX
-mx__1 = casadi__MX__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__2" c_casadi__MX__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__2
-  :: MX -> IO MX
-casadi__MX__CONSTRUCTOR__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__2 :: MX -> IO MX
-mx__2 = casadi__MX__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__3" c_casadi__MX__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__3
-  :: Double -> IO MX
-casadi__MX__CONSTRUCTOR__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__3 :: Double -> IO MX
-mx__3 = casadi__MX__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__4" c_casadi__MX__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__4
-  :: Sparsity -> MX -> IO MX
-casadi__MX__CONSTRUCTOR__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__4 :: Sparsity -> MX -> IO MX
-mx__4 = casadi__MX__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__5" c_casadi__MX__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__5
-  :: Sparsity -> IO MX
-casadi__MX__CONSTRUCTOR__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__5 :: Sparsity -> IO MX
-mx__5 = casadi__MX__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__6" c_casadi__MX__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__6
-  :: Int -> Int -> IO MX
-casadi__MX__CONSTRUCTOR__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__6 :: Int -> Int -> IO MX
-mx__6 = casadi__MX__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__7" c_casadi__MX__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> IO (Ptr MX')
-casadi__MX__CONSTRUCTOR__7
-  :: IO MX
-casadi__MX__CONSTRUCTOR__7  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__CONSTRUCTOR__7 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx__7 :: IO MX
-mx__7 = casadi__MX__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__T" c_casadi__MX__T
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__T
-  :: MX -> IO MX
-casadi__MX__T x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__T errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_T :: MXClass a => a -> IO MX
-mx_T x = casadi__MX__T (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX____nonzero__" c_casadi__MX____nonzero__
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX____nonzero__
-  :: MX -> IO Bool
-casadi__MX____nonzero__ x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX____nonzero__ errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx___nonzero__ :: MXClass a => a -> IO Bool
-mx___nonzero__ x = casadi__MX____nonzero__ (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__append" c_casadi__MX__append
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO ()
-casadi__MX__append
-  :: MX -> MX -> IO ()
-casadi__MX__append x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__append errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_append :: MXClass a => a -> MX -> IO ()
-mx_append x = casadi__MX__append (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__appendColumns" c_casadi__MX__appendColumns
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO ()
-casadi__MX__appendColumns
-  :: MX -> MX -> IO ()
-casadi__MX__appendColumns x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__appendColumns errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_appendColumns :: MXClass a => a -> MX -> IO ()
-mx_appendColumns x = casadi__MX__appendColumns (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__attachAssert__0" c_casadi__MX__attachAssert__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__attachAssert__0
-  :: MX -> MX -> IO MX
-casadi__MX__attachAssert__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__attachAssert__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_attachAssert__0 :: MXClass a => a -> MX -> IO MX
-mx_attachAssert__0 x = casadi__MX__attachAssert__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__attachAssert__1" c_casadi__MX__attachAssert__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
-casadi__MX__attachAssert__1
-  :: MX -> MX -> String -> IO MX
-casadi__MX__attachAssert__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__attachAssert__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_attachAssert__1 :: MXClass a => a -> MX -> String -> IO MX
-mx_attachAssert__1 x = casadi__MX__attachAssert__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__binary" c_casadi__MX__binary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__binary
-  :: Int -> MX -> MX -> IO MX
-casadi__MX__binary x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__binary errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_binary :: Int -> MX -> MX -> IO MX
-mx_binary = casadi__MX__binary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__colind" c_casadi__MX__colind
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
-casadi__MX__colind
-  :: MX -> Int -> IO Int
-casadi__MX__colind x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__colind errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_colind :: MXClass a => a -> Int -> IO Int
-mx_colind x = casadi__MX__colind (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__dimString" c_casadi__MX__dimString
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString)
-casadi__MX__dimString
-  :: MX -> IO String
-casadi__MX__dimString x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__dimString errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_dimString :: MXClass a => a -> IO String
-mx_dimString x = casadi__MX__dimString (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__enlarge__0" c_casadi__MX__enlarge__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__MX__enlarge__0
-  :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-casadi__MX__enlarge__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_enlarge__0 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-mx_enlarge__0 x = casadi__MX__enlarge__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__enlarge__1" c_casadi__MX__enlarge__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__MX__enlarge__1
-  :: MX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__MX__enlarge__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_enlarge__1 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-mx_enlarge__1 x = casadi__MX__enlarge__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__erase__0" c_casadi__MX__erase__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO ()
-casadi__MX__erase__0
-  :: MX -> Vector Int -> IO ()
-casadi__MX__erase__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__erase__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_erase__0 :: MXClass a => a -> Vector Int -> IO ()
-mx_erase__0 x = casadi__MX__erase__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__erase__1" c_casadi__MX__erase__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__MX__erase__1
-  :: MX -> Vector Int -> Bool -> IO ()
-casadi__MX__erase__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__erase__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_erase__1 :: MXClass a => a -> Vector Int -> Bool -> IO ()
-mx_erase__1 x = casadi__MX__erase__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__erase__2" c_casadi__MX__erase__2
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__MX__erase__2
-  :: MX -> Vector Int -> Vector Int -> IO ()
-casadi__MX__erase__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__erase__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_erase__2 :: MXClass a => a -> Vector Int -> Vector Int -> IO ()
-mx_erase__2 x = casadi__MX__erase__2 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__erase__3" c_casadi__MX__erase__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__MX__erase__3
-  :: MX -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__MX__erase__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__erase__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_erase__3 :: MXClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
-mx_erase__3 x = casadi__MX__erase__3 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__eye" c_casadi__MX__eye
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
-casadi__MX__eye
-  :: Int -> IO MX
-casadi__MX__eye x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__eye errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_eye :: Int -> IO MX
-mx_eye = casadi__MX__eye
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__find__0" c_casadi__MX__find__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt))
-casadi__MX__find__0
-  :: MX -> IO (Vector Int)
-casadi__MX__find__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__find__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_find__0 :: MXClass a => a -> IO (Vector Int)
-mx_find__0 x = casadi__MX__find__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__find__1" c_casadi__MX__find__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__MX__find__1
-  :: MX -> Bool -> IO (Vector Int)
-casadi__MX__find__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__find__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_find__1 :: MXClass a => a -> Bool -> IO (Vector Int)
-mx_find__1 x = casadi__MX__find__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__get__0" c_casadi__MX__get__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__MX__get__0
-  :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__MX__get__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__get__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_get__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
-mx_get__0 x = casadi__MX__get__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__get__1" c_casadi__MX__get__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__MX__get__1
-  :: MX -> MX -> Bool -> IMatrix -> Slice -> IO ()
-casadi__MX__get__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__get__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_get__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO ()
-mx_get__1 x = casadi__MX__get__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__get__2" c_casadi__MX__get__2
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__MX__get__2
-  :: MX -> MX -> Bool -> Slice -> IMatrix -> IO ()
-casadi__MX__get__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__get__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_get__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO ()
-mx_get__2 x = casadi__MX__get__2 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__get__3" c_casadi__MX__get__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__MX__get__3
-  :: MX -> MX -> Bool -> Slice -> Slice -> IO ()
-casadi__MX__get__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__get__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_get__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO ()
-mx_get__3 x = casadi__MX__get__3 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__get__4" c_casadi__MX__get__4
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__MX__get__4
-  :: MX -> MX -> Bool -> Sparsity -> IO ()
-casadi__MX__get__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__get__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_get__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO ()
-mx_get__4 x = casadi__MX__get__4 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__get__5" c_casadi__MX__get__5
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__MX__get__5
-  :: MX -> MX -> Bool -> IMatrix -> IO ()
-casadi__MX__get__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__get__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_get__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO ()
-mx_get__5 x = casadi__MX__get__5 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__get__6" c_casadi__MX__get__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
-casadi__MX__get__6
-  :: MX -> MX -> Bool -> Slice -> IO ()
-casadi__MX__get__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__get__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_get__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
-mx_get__6 x = casadi__MX__get__6 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getColind" c_casadi__MX__getColind
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt))
-casadi__MX__getColind
-  :: MX -> IO (Vector Int)
-casadi__MX__getColind x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getColind errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getColind :: MXClass a => a -> IO (Vector Int)
-mx_getColind x = casadi__MX__getColind (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getDep__0" c_casadi__MX__getDep__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__getDep__0
-  :: MX -> IO MX
-casadi__MX__getDep__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getDep__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getDep__0 :: MXClass a => a -> IO MX
-mx_getDep__0 x = casadi__MX__getDep__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getDep__1" c_casadi__MX__getDep__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi__MX__getDep__1
-  :: MX -> Int -> IO MX
-casadi__MX__getDep__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getDep__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getDep__1 :: MXClass a => a -> Int -> IO MX
-mx_getDep__1 x = casadi__MX__getDep__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getEqualityCheckingDepth" c_casadi__MX__getEqualityCheckingDepth
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__MX__getEqualityCheckingDepth
-  :: IO Int
-casadi__MX__getEqualityCheckingDepth  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getEqualityCheckingDepth errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getEqualityCheckingDepth :: IO Int
-mx_getEqualityCheckingDepth = casadi__MX__getEqualityCheckingDepth
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getEvaluationOutput" c_casadi__MX__getEvaluationOutput
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__getEvaluationOutput
-  :: MX -> IO Int
-casadi__MX__getEvaluationOutput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getEvaluationOutput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getEvaluationOutput :: MXClass a => a -> IO Int
-mx_getEvaluationOutput x = casadi__MX__getEvaluationOutput (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getFunction__0" c_casadi__MX__getFunction__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Function')
-casadi__MX__getFunction__0
-  :: MX -> IO Function
-casadi__MX__getFunction__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getFunction__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getFunction__0 :: MXClass a => a -> IO Function
-mx_getFunction__0 x = casadi__MX__getFunction__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getFunction__1" c_casadi__MX__getFunction__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr Function')
-casadi__MX__getFunction__1
-  :: MX -> Int -> IO Function
-casadi__MX__getFunction__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getFunction__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getFunction__1 :: MXClass a => a -> Int -> IO Function
-mx_getFunction__1 x = casadi__MX__getFunction__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getMatrixValue" c_casadi__MX__getMatrixValue
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr DMatrix')
-casadi__MX__getMatrixValue
-  :: MX -> IO DMatrix
-casadi__MX__getMatrixValue x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getMatrixValue errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getMatrixValue :: MXClass a => a -> IO DMatrix
-mx_getMatrixValue x = casadi__MX__getMatrixValue (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getNZ__0" c_casadi__MX__getNZ__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__MX__getNZ__0
-  :: MX -> MX -> Bool -> IMatrix -> IO ()
-casadi__MX__getNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO ()
-mx_getNZ__0 x = casadi__MX__getNZ__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getNZ__1" c_casadi__MX__getNZ__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
-casadi__MX__getNZ__1
-  :: MX -> MX -> Bool -> Slice -> IO ()
-casadi__MX__getNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
-mx_getNZ__1 x = casadi__MX__getNZ__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getName" c_casadi__MX__getName
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString)
-casadi__MX__getName
-  :: MX -> IO String
-casadi__MX__getName x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getName errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getName :: MXClass a => a -> IO String
-mx_getName x = casadi__MX__getName (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getNdeps" c_casadi__MX__getNdeps
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__getNdeps
-  :: MX -> IO Int
-casadi__MX__getNdeps x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getNdeps errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getNdeps :: MXClass a => a -> IO Int
-mx_getNdeps x = casadi__MX__getNdeps (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getOp" c_casadi__MX__getOp
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__getOp
-  :: MX -> IO Int
-casadi__MX__getOp x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getOp errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getOp :: MXClass a => a -> IO Int
-mx_getOp x = casadi__MX__getOp (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getOutput__0" c_casadi__MX__getOutput__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__getOutput__0
-  :: MX -> IO MX
-casadi__MX__getOutput__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getOutput__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getOutput__0 :: MXClass a => a -> IO MX
-mx_getOutput__0 x = casadi__MX__getOutput__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getOutput__1" c_casadi__MX__getOutput__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi__MX__getOutput__1
-  :: MX -> Int -> IO MX
-casadi__MX__getOutput__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getOutput__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getOutput__1 :: MXClass a => a -> Int -> IO MX
-mx_getOutput__1 x = casadi__MX__getOutput__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getPrimitives" c_casadi__MX__getPrimitives
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-casadi__MX__getPrimitives
-  :: MX -> IO (Vector MX)
-casadi__MX__getPrimitives x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getPrimitives errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getPrimitives :: MXClass a => a -> IO (Vector MX)
-mx_getPrimitives x = casadi__MX__getPrimitives (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getRow" c_casadi__MX__getRow
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt))
-casadi__MX__getRow
-  :: MX -> IO (Vector Int)
-casadi__MX__getRow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getRow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getRow :: MXClass a => a -> IO (Vector Int)
-mx_getRow x = casadi__MX__getRow (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getSparsity" c_casadi__MX__getSparsity
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity')
-casadi__MX__getSparsity
-  :: MX -> IO Sparsity
-casadi__MX__getSparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getSparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getSparsity :: MXClass a => a -> IO Sparsity
-mx_getSparsity x = casadi__MX__getSparsity (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getTemp" c_casadi__MX__getTemp
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__getTemp
-  :: MX -> IO Int
-casadi__MX__getTemp x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getTemp errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getTemp :: MXClass a => a -> IO Int
-mx_getTemp x = casadi__MX__getTemp (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__getValue" c_casadi__MX__getValue
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CDouble
-casadi__MX__getValue
-  :: MX -> IO Double
-casadi__MX__getValue x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__getValue errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_getValue :: MXClass a => a -> IO Double
-mx_getValue x = casadi__MX__getValue (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__hasDuplicates" c_casadi__MX__hasDuplicates
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__hasDuplicates
-  :: MX -> IO Bool
-casadi__MX__hasDuplicates x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__hasDuplicates errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_hasDuplicates :: MXClass a => a -> IO Bool
-mx_hasDuplicates x = casadi__MX__hasDuplicates (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__inf__0" c_casadi__MX__inf__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi__MX__inf__0
-  :: (Int, Int) -> IO MX
-casadi__MX__inf__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__inf__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_inf__0 :: (Int, Int) -> IO MX
-mx_inf__0 = casadi__MX__inf__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__inf__1" c_casadi__MX__inf__1
-  :: Ptr (Ptr StdString) -> IO (Ptr MX')
-casadi__MX__inf__1
-  :: IO MX
-casadi__MX__inf__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__inf__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_inf__1 :: IO MX
-mx_inf__1 = casadi__MX__inf__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__inf__2" c_casadi__MX__inf__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
-casadi__MX__inf__2
-  :: Int -> IO MX
-casadi__MX__inf__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__inf__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_inf__2 :: Int -> IO MX
-mx_inf__2 = casadi__MX__inf__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__inf__3" c_casadi__MX__inf__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
-casadi__MX__inf__3
-  :: Int -> Int -> IO MX
-casadi__MX__inf__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__inf__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_inf__3 :: Int -> Int -> IO MX
-mx_inf__3 = casadi__MX__inf__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__inf__4" c_casadi__MX__inf__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__MX__inf__4
-  :: Sparsity -> IO MX
-casadi__MX__inf__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__inf__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_inf__4 :: Sparsity -> IO MX
-mx_inf__4 = casadi__MX__inf__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isBinary" c_casadi__MX__isBinary
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isBinary
-  :: MX -> IO Bool
-casadi__MX__isBinary x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isBinary errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isBinary :: MXClass a => a -> IO Bool
-mx_isBinary x = casadi__MX__isBinary (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isCommutative" c_casadi__MX__isCommutative
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isCommutative
-  :: MX -> IO Bool
-casadi__MX__isCommutative x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isCommutative errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isCommutative :: MXClass a => a -> IO Bool
-mx_isCommutative x = casadi__MX__isCommutative (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isConstant" c_casadi__MX__isConstant
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isConstant
-  :: MX -> IO Bool
-casadi__MX__isConstant x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isConstant errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isConstant :: MXClass a => a -> IO Bool
-mx_isConstant x = casadi__MX__isConstant (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isEvaluation" c_casadi__MX__isEvaluation
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isEvaluation
-  :: MX -> IO Bool
-casadi__MX__isEvaluation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isEvaluation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isEvaluation :: MXClass a => a -> IO Bool
-mx_isEvaluation x = casadi__MX__isEvaluation (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isEvaluationOutput" c_casadi__MX__isEvaluationOutput
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isEvaluationOutput
-  :: MX -> IO Bool
-casadi__MX__isEvaluationOutput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isEvaluationOutput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isEvaluationOutput :: MXClass a => a -> IO Bool
-mx_isEvaluationOutput x = casadi__MX__isEvaluationOutput (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isIdentity" c_casadi__MX__isIdentity
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isIdentity
-  :: MX -> IO Bool
-casadi__MX__isIdentity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isIdentity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isIdentity :: MXClass a => a -> IO Bool
-mx_isIdentity x = casadi__MX__isIdentity (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isMinusOne" c_casadi__MX__isMinusOne
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isMinusOne
-  :: MX -> IO Bool
-casadi__MX__isMinusOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isMinusOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isMinusOne :: MXClass a => a -> IO Bool
-mx_isMinusOne x = casadi__MX__isMinusOne (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isMultiplication" c_casadi__MX__isMultiplication
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isMultiplication
-  :: MX -> IO Bool
-casadi__MX__isMultiplication x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isMultiplication errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isMultiplication :: MXClass a => a -> IO Bool
-mx_isMultiplication x = casadi__MX__isMultiplication (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isNorm" c_casadi__MX__isNorm
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isNorm
-  :: MX -> IO Bool
-casadi__MX__isNorm x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isNorm errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isNorm :: MXClass a => a -> IO Bool
-mx_isNorm x = casadi__MX__isNorm (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isOne" c_casadi__MX__isOne
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isOne
-  :: MX -> IO Bool
-casadi__MX__isOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isOne :: MXClass a => a -> IO Bool
-mx_isOne x = casadi__MX__isOne (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isOperation" c_casadi__MX__isOperation
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
-casadi__MX__isOperation
-  :: MX -> Int -> IO Bool
-casadi__MX__isOperation x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isOperation errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isOperation :: MXClass a => a -> Int -> IO Bool
-mx_isOperation x = casadi__MX__isOperation (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isRegular" c_casadi__MX__isRegular
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isRegular
-  :: MX -> IO Bool
-casadi__MX__isRegular x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isRegular errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isRegular :: MXClass a => a -> IO Bool
-mx_isRegular x = casadi__MX__isRegular (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isSymbolic" c_casadi__MX__isSymbolic
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isSymbolic
-  :: MX -> IO Bool
-casadi__MX__isSymbolic x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isSymbolic errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isSymbolic :: MXClass a => a -> IO Bool
-mx_isSymbolic x = casadi__MX__isSymbolic (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isTranspose" c_casadi__MX__isTranspose
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isTranspose
-  :: MX -> IO Bool
-casadi__MX__isTranspose x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isTranspose errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isTranspose :: MXClass a => a -> IO Bool
-mx_isTranspose x = casadi__MX__isTranspose (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isUnary" c_casadi__MX__isUnary
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isUnary
-  :: MX -> IO Bool
-casadi__MX__isUnary x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isUnary errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isUnary :: MXClass a => a -> IO Bool
-mx_isUnary x = casadi__MX__isUnary (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isValidInput" c_casadi__MX__isValidInput
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isValidInput
-  :: MX -> IO Bool
-casadi__MX__isValidInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isValidInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isValidInput :: MXClass a => a -> IO Bool
-mx_isValidInput x = casadi__MX__isValidInput (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isZero" c_casadi__MX__isZero
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isZero
-  :: MX -> IO Bool
-casadi__MX__isZero x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isZero errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isZero :: MXClass a => a -> IO Bool
-mx_isZero x = casadi__MX__isZero (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__iscolumn" c_casadi__MX__iscolumn
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__iscolumn
-  :: MX -> IO Bool
-casadi__MX__iscolumn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__iscolumn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_iscolumn :: MXClass a => a -> IO Bool
-mx_iscolumn x = casadi__MX__iscolumn (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isdense" c_casadi__MX__isdense
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isdense
-  :: MX -> IO Bool
-casadi__MX__isdense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isdense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isdense :: MXClass a => a -> IO Bool
-mx_isdense x = casadi__MX__isdense (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isempty__0" c_casadi__MX__isempty__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isempty__0
-  :: MX -> IO Bool
-casadi__MX__isempty__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isempty__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isempty__0 :: MXClass a => a -> IO Bool
-mx_isempty__0 x = casadi__MX__isempty__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isempty__1" c_casadi__MX__isempty__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
-casadi__MX__isempty__1
-  :: MX -> Bool -> IO Bool
-casadi__MX__isempty__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isempty__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isempty__1 :: MXClass a => a -> Bool -> IO Bool
-mx_isempty__1 x = casadi__MX__isempty__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isrow" c_casadi__MX__isrow
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isrow
-  :: MX -> IO Bool
-casadi__MX__isrow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isrow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isrow :: MXClass a => a -> IO Bool
-mx_isrow x = casadi__MX__isrow (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isscalar__0" c_casadi__MX__isscalar__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isscalar__0
-  :: MX -> IO Bool
-casadi__MX__isscalar__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isscalar__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isscalar__0 :: MXClass a => a -> IO Bool
-mx_isscalar__0 x = casadi__MX__isscalar__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isscalar__1" c_casadi__MX__isscalar__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
-casadi__MX__isscalar__1
-  :: MX -> Bool -> IO Bool
-casadi__MX__isscalar__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isscalar__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isscalar__1 :: MXClass a => a -> Bool -> IO Bool
-mx_isscalar__1 x = casadi__MX__isscalar__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__issquare" c_casadi__MX__issquare
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__issquare
-  :: MX -> IO Bool
-casadi__MX__issquare x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__issquare errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_issquare :: MXClass a => a -> IO Bool
-mx_issquare x = casadi__MX__issquare (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__istril" c_casadi__MX__istril
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__istril
-  :: MX -> IO Bool
-casadi__MX__istril x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__istril errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_istril :: MXClass a => a -> IO Bool
-mx_istril x = casadi__MX__istril (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__istriu" c_casadi__MX__istriu
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__istriu
-  :: MX -> IO Bool
-casadi__MX__istriu x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__istriu errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_istriu :: MXClass a => a -> IO Bool
-mx_istriu x = casadi__MX__istriu (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__isvector" c_casadi__MX__isvector
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__isvector
-  :: MX -> IO Bool
-casadi__MX__isvector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__isvector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_isvector :: MXClass a => a -> IO Bool
-mx_isvector x = casadi__MX__isvector (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__joinPrimitives" c_casadi__MX__joinPrimitives
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi__MX__joinPrimitives
-  :: MX -> Vector MX -> IO MX
-casadi__MX__joinPrimitives x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__joinPrimitives errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_joinPrimitives :: MXClass a => a -> Vector MX -> IO MX
-mx_joinPrimitives x = casadi__MX__joinPrimitives (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__lift" c_casadi__MX__lift
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO ()
-casadi__MX__lift
-  :: MX -> MX -> IO ()
-casadi__MX__lift x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__lift errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_lift :: MXClass a => a -> MX -> IO ()
-mx_lift x = casadi__MX__lift (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__makeDense__0" c_casadi__MX__makeDense__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
-casadi__MX__makeDense__0
-  :: MX -> IO ()
-casadi__MX__makeDense__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__makeDense__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_makeDense__0 :: MXClass a => a -> IO ()
-mx_makeDense__0 x = casadi__MX__makeDense__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__makeDense__1" c_casadi__MX__makeDense__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO ()
-casadi__MX__makeDense__1
-  :: MX -> MX -> IO ()
-casadi__MX__makeDense__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__makeDense__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_makeDense__1 :: MXClass a => a -> MX -> IO ()
-mx_makeDense__1 x = casadi__MX__makeDense__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__mapping" c_casadi__MX__mapping
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr IMatrix')
-casadi__MX__mapping
-  :: MX -> IO IMatrix
-casadi__MX__mapping x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__mapping errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_mapping :: MXClass a => a -> IO IMatrix
-mx_mapping x = casadi__MX__mapping (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__monitor" c_casadi__MX__monitor
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
-casadi__MX__monitor
-  :: MX -> String -> IO MX
-casadi__MX__monitor x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__monitor errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_monitor :: MXClass a => a -> String -> IO MX
-mx_monitor x = casadi__MX__monitor (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__nOut" c_casadi__MX__nOut
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__nOut
-  :: MX -> IO Int
-casadi__MX__nOut x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__nOut errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_nOut :: MXClass a => a -> IO Int
-mx_nOut x = casadi__MX__nOut (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__nan__0" c_casadi__MX__nan__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi__MX__nan__0
-  :: (Int, Int) -> IO MX
-casadi__MX__nan__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__nan__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_nan__0 :: (Int, Int) -> IO MX
-mx_nan__0 = casadi__MX__nan__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__nan__1" c_casadi__MX__nan__1
-  :: Ptr (Ptr StdString) -> IO (Ptr MX')
-casadi__MX__nan__1
-  :: IO MX
-casadi__MX__nan__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__nan__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_nan__1 :: IO MX
-mx_nan__1 = casadi__MX__nan__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__nan__2" c_casadi__MX__nan__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
-casadi__MX__nan__2
-  :: Int -> IO MX
-casadi__MX__nan__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__nan__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_nan__2 :: Int -> IO MX
-mx_nan__2 = casadi__MX__nan__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__nan__3" c_casadi__MX__nan__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
-casadi__MX__nan__3
-  :: Int -> Int -> IO MX
-casadi__MX__nan__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__nan__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_nan__3 :: Int -> Int -> IO MX
-mx_nan__3 = casadi__MX__nan__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__nan__4" c_casadi__MX__nan__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__MX__nan__4
-  :: Sparsity -> IO MX
-casadi__MX__nan__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__nan__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_nan__4 :: Sparsity -> IO MX
-mx_nan__4 = casadi__MX__nan__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__nnz" c_casadi__MX__nnz
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__nnz
-  :: MX -> IO Int
-casadi__MX__nnz x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__nnz errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_nnz :: MXClass a => a -> IO Int
-mx_nnz x = casadi__MX__nnz (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__numFunctions" c_casadi__MX__numFunctions
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__numFunctions
-  :: MX -> IO Int
-casadi__MX__numFunctions x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__numFunctions errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_numFunctions :: MXClass a => a -> IO Int
-mx_numFunctions x = casadi__MX__numFunctions (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__numPrimitives" c_casadi__MX__numPrimitives
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__numPrimitives
-  :: MX -> IO Int
-casadi__MX__numPrimitives x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__numPrimitives errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_numPrimitives :: MXClass a => a -> IO Int
-mx_numPrimitives x = casadi__MX__numPrimitives (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__numel__0" c_casadi__MX__numel__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
-casadi__MX__numel__0
-  :: MX -> Int -> IO Int
-casadi__MX__numel__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__numel__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_numel__0 :: MXClass a => a -> Int -> IO Int
-mx_numel__0 x = casadi__MX__numel__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__numel__1" c_casadi__MX__numel__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__numel__1
-  :: MX -> IO Int
-casadi__MX__numel__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__numel__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_numel__1 :: MXClass a => a -> IO Int
-mx_numel__1 x = casadi__MX__numel__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__ones__0" c_casadi__MX__ones__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi__MX__ones__0
-  :: (Int, Int) -> IO MX
-casadi__MX__ones__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__ones__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_ones__0 :: (Int, Int) -> IO MX
-mx_ones__0 = casadi__MX__ones__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__ones__1" c_casadi__MX__ones__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__MX__ones__1
-  :: Sparsity -> IO MX
-casadi__MX__ones__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__ones__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_ones__1 :: Sparsity -> IO MX
-mx_ones__1 = casadi__MX__ones__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__ones__2" c_casadi__MX__ones__2
-  :: Ptr (Ptr StdString) -> IO (Ptr MX')
-casadi__MX__ones__2
-  :: IO MX
-casadi__MX__ones__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__ones__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_ones__2 :: IO MX
-mx_ones__2 = casadi__MX__ones__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__ones__3" c_casadi__MX__ones__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
-casadi__MX__ones__3
-  :: Int -> IO MX
-casadi__MX__ones__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__ones__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_ones__3 :: Int -> IO MX
-mx_ones__3 = casadi__MX__ones__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__ones__4" c_casadi__MX__ones__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
-casadi__MX__ones__4
-  :: Int -> Int -> IO MX
-casadi__MX__ones__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__ones__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_ones__4 :: Int -> Int -> IO MX
-mx_ones__4 = casadi__MX__ones__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__operator_minus" c_casadi__MX__operator_minus
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__operator_minus
-  :: MX -> IO MX
-casadi__MX__operator_minus x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__operator_minus errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_operator_minus :: MXClass a => a -> IO MX
-mx_operator_minus x = casadi__MX__operator_minus (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__printme" c_casadi__MX__printme
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__printme
-  :: MX -> MX -> IO MX
-casadi__MX__printme x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__printme errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_printme :: MXClass a => a -> MX -> IO MX
-mx_printme x = casadi__MX__printme (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__resetInput" c_casadi__MX__resetInput
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
-casadi__MX__resetInput
-  :: MX -> IO ()
-casadi__MX__resetInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__resetInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_resetInput :: MXClass a => a -> IO ()
-mx_resetInput x = casadi__MX__resetInput (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__row" c_casadi__MX__row
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
-casadi__MX__row
-  :: MX -> Int -> IO Int
-casadi__MX__row x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__row errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_row :: MXClass a => a -> Int -> IO Int
-mx_row x = casadi__MX__row (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__set__0" c_casadi__MX__set__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__MX__set__0
-  :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__MX__set__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__set__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_set__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
-mx_set__0 x = casadi__MX__set__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__set__1" c_casadi__MX__set__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__MX__set__1
-  :: MX -> MX -> Bool -> IMatrix -> Slice -> IO ()
-casadi__MX__set__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__set__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_set__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO ()
-mx_set__1 x = casadi__MX__set__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__set__2" c_casadi__MX__set__2
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__MX__set__2
-  :: MX -> MX -> Bool -> Slice -> IMatrix -> IO ()
-casadi__MX__set__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__set__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_set__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO ()
-mx_set__2 x = casadi__MX__set__2 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__set__3" c_casadi__MX__set__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__MX__set__3
-  :: MX -> MX -> Bool -> Slice -> Slice -> IO ()
-casadi__MX__set__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__set__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_set__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO ()
-mx_set__3 x = casadi__MX__set__3 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__set__4" c_casadi__MX__set__4
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__MX__set__4
-  :: MX -> MX -> Bool -> Sparsity -> IO ()
-casadi__MX__set__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__set__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_set__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO ()
-mx_set__4 x = casadi__MX__set__4 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__set__5" c_casadi__MX__set__5
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__MX__set__5
-  :: MX -> MX -> Bool -> IMatrix -> IO ()
-casadi__MX__set__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__set__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_set__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO ()
-mx_set__5 x = casadi__MX__set__5 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__set__6" c_casadi__MX__set__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
-casadi__MX__set__6
-  :: MX -> MX -> Bool -> Slice -> IO ()
-casadi__MX__set__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__set__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_set__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
-mx_set__6 x = casadi__MX__set__6 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__0" c_casadi__MX__setEqualityCheckingDepth__0
-  :: Ptr (Ptr StdString) -> IO ()
-casadi__MX__setEqualityCheckingDepth__0
-  :: IO ()
-casadi__MX__setEqualityCheckingDepth__0  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__setEqualityCheckingDepth__0 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_setEqualityCheckingDepth__0 :: IO ()
-mx_setEqualityCheckingDepth__0 = casadi__MX__setEqualityCheckingDepth__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__1" c_casadi__MX__setEqualityCheckingDepth__1
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__MX__setEqualityCheckingDepth__1
-  :: Int -> IO ()
-casadi__MX__setEqualityCheckingDepth__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__setEqualityCheckingDepth__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_setEqualityCheckingDepth__1 :: Int -> IO ()
-mx_setEqualityCheckingDepth__1 = casadi__MX__setEqualityCheckingDepth__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__setNZ__0" c_casadi__MX__setNZ__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__MX__setNZ__0
-  :: MX -> MX -> Bool -> IMatrix -> IO ()
-casadi__MX__setNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__setNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_setNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO ()
-mx_setNZ__0 x = casadi__MX__setNZ__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__setNZ__1" c_casadi__MX__setNZ__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
-casadi__MX__setNZ__1
-  :: MX -> MX -> Bool -> Slice -> IO ()
-casadi__MX__setNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__setNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_setNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
-mx_setNZ__1 x = casadi__MX__setNZ__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__setTemp" c_casadi__MX__setTemp
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO ()
-casadi__MX__setTemp
-  :: MX -> Int -> IO ()
-casadi__MX__setTemp x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__setTemp errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_setTemp :: MXClass a => a -> Int -> IO ()
-mx_setTemp x = casadi__MX__setTemp (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__shape__0" c_casadi__MX__shape__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
-casadi__MX__shape__0
-  :: MX -> Int -> IO Int
-casadi__MX__shape__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__shape__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_shape__0 :: MXClass a => a -> Int -> IO Int
-mx_shape__0 x = casadi__MX__shape__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__shape__1" c_casadi__MX__shape__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdPair CInt CInt))
-casadi__MX__shape__1
-  :: MX -> IO (Int, Int)
-casadi__MX__shape__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__shape__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_shape__1 :: MXClass a => a -> IO (Int, Int)
-mx_shape__1 x = casadi__MX__shape__1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__size" c_casadi__MX__size
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__size
-  :: MX -> IO Int
-casadi__MX__size x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__size errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_size :: MXClass a => a -> IO Int
-mx_size x = casadi__MX__size (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__size1" c_casadi__MX__size1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__size1
-  :: MX -> IO Int
-casadi__MX__size1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__size1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_size1 :: MXClass a => a -> IO Int
-mx_size1 x = casadi__MX__size1 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__size2" c_casadi__MX__size2
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__size2
-  :: MX -> IO Int
-casadi__MX__size2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__size2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_size2 :: MXClass a => a -> IO Int
-mx_size2 x = casadi__MX__size2 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sizeD" c_casadi__MX__sizeD
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__sizeD
-  :: MX -> IO Int
-casadi__MX__sizeD x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sizeD errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sizeD :: MXClass a => a -> IO Int
-mx_sizeD x = casadi__MX__sizeD (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sizeL" c_casadi__MX__sizeL
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__sizeL
-  :: MX -> IO Int
-casadi__MX__sizeL x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sizeL errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sizeL :: MXClass a => a -> IO Int
-mx_sizeL x = casadi__MX__sizeL (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sizeU" c_casadi__MX__sizeU
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi__MX__sizeU
-  :: MX -> IO Int
-casadi__MX__sizeU x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sizeU errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sizeU :: MXClass a => a -> IO Int
-mx_sizeU x = casadi__MX__sizeU (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sparse__0" c_casadi__MX__sparse__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__sparse__0
-  :: Sparsity -> MX -> IO MX
-casadi__MX__sparse__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sparse__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sparse__0 :: Sparsity -> MX -> IO MX
-mx_sparse__0 = casadi__MX__sparse__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sparse__1" c_casadi__MX__sparse__1
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi__MX__sparse__1
-  :: (Int, Int) -> IO MX
-casadi__MX__sparse__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sparse__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sparse__1 :: (Int, Int) -> IO MX
-mx_sparse__1 = casadi__MX__sparse__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sparse__2" c_casadi__MX__sparse__2
-  :: Ptr (Ptr StdString) -> IO (Ptr MX')
-casadi__MX__sparse__2
-  :: IO MX
-casadi__MX__sparse__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sparse__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sparse__2 :: IO MX
-mx_sparse__2 = casadi__MX__sparse__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sparse__3" c_casadi__MX__sparse__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
-casadi__MX__sparse__3
-  :: Int -> IO MX
-casadi__MX__sparse__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sparse__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sparse__3 :: Int -> IO MX
-mx_sparse__3 = casadi__MX__sparse__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sparse__4" c_casadi__MX__sparse__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
-casadi__MX__sparse__4
-  :: Int -> Int -> IO MX
-casadi__MX__sparse__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sparse__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sparse__4 :: Int -> Int -> IO MX
-mx_sparse__4 = casadi__MX__sparse__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sparsity" c_casadi__MX__sparsity
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity')
-casadi__MX__sparsity
-  :: MX -> IO Sparsity
-casadi__MX__sparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sparsity :: MXClass a => a -> IO Sparsity
-mx_sparsity x = casadi__MX__sparsity (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__splitPrimitives" c_casadi__MX__splitPrimitives
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-casadi__MX__splitPrimitives
-  :: MX -> MX -> IO (Vector MX)
-casadi__MX__splitPrimitives x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__splitPrimitives errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_splitPrimitives :: MXClass a => a -> MX -> IO (Vector MX)
-mx_splitPrimitives x = casadi__MX__splitPrimitives (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__0" c_casadi__MX__sym__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi__MX__sym__0
-  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
-casadi__MX__sym__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
-mx_sym__0 = casadi__MX__sym__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__1" c_casadi__MX__sym__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi__MX__sym__1
-  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
-casadi__MX__sym__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
-mx_sym__1 = casadi__MX__sym__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__2" c_casadi__MX__sym__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi__MX__sym__2
-  :: String -> Int -> Int -> Int -> IO (Vector MX)
-casadi__MX__sym__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector MX)
-mx_sym__2 = casadi__MX__sym__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__3" c_casadi__MX__sym__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi__MX__sym__3
-  :: String -> Sparsity -> Int -> IO (Vector MX)
-casadi__MX__sym__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__3 :: String -> Sparsity -> Int -> IO (Vector MX)
-mx_sym__3 = casadi__MX__sym__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__4" c_casadi__MX__sym__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__MX__sym__4
-  :: String -> Sparsity -> IO MX
-casadi__MX__sym__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__4 :: String -> Sparsity -> IO MX
-mx_sym__4 = casadi__MX__sym__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__5" c_casadi__MX__sym__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi__MX__sym__5
-  :: String -> (Int, Int) -> IO MX
-casadi__MX__sym__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__5 :: String -> (Int, Int) -> IO MX
-mx_sym__5 = casadi__MX__sym__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__6" c_casadi__MX__sym__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr MX')
-casadi__MX__sym__6
-  :: String -> IO MX
-casadi__MX__sym__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__6 :: String -> IO MX
-mx_sym__6 = casadi__MX__sym__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__7" c_casadi__MX__sym__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__MX__sym__7
-  :: String -> Int -> IO MX
-casadi__MX__sym__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__7 :: String -> Int -> IO MX
-mx_sym__7 = casadi__MX__sym__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__sym__8" c_casadi__MX__sym__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
-casadi__MX__sym__8
-  :: String -> Int -> Int -> IO MX
-casadi__MX__sym__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__sym__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_sym__8 :: String -> Int -> Int -> IO MX
-mx_sym__8 = casadi__MX__sym__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__unary" c_casadi__MX__unary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> IO (Ptr MX')
-casadi__MX__unary
-  :: Int -> MX -> IO MX
-casadi__MX__unary x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__unary errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_unary :: Int -> MX -> IO MX
-mx_unary = casadi__MX__unary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__zeros__0" c_casadi__MX__zeros__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi__MX__zeros__0
-  :: (Int, Int) -> IO MX
-casadi__MX__zeros__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__zeros__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_zeros__0 :: (Int, Int) -> IO MX
-mx_zeros__0 = casadi__MX__zeros__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__zeros__1" c_casadi__MX__zeros__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__MX__zeros__1
-  :: Sparsity -> IO MX
-casadi__MX__zeros__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__zeros__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_zeros__1 :: Sparsity -> IO MX
-mx_zeros__1 = casadi__MX__zeros__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__zeros__2" c_casadi__MX__zeros__2
-  :: Ptr (Ptr StdString) -> IO (Ptr MX')
-casadi__MX__zeros__2
-  :: IO MX
-casadi__MX__zeros__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__zeros__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_zeros__2 :: IO MX
-mx_zeros__2 = casadi__MX__zeros__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__zeros__3" c_casadi__MX__zeros__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
-casadi__MX__zeros__3
-  :: Int -> IO MX
-casadi__MX__zeros__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__zeros__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_zeros__3 :: Int -> IO MX
-mx_zeros__3 = casadi__MX__zeros__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__zeros__4" c_casadi__MX__zeros__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
-casadi__MX__zeros__4
-  :: Int -> Int -> IO MX
-casadi__MX__zeros__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__zeros__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_zeros__4 :: Int -> Int -> IO MX
-mx_zeros__4 = casadi__MX__zeros__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__zz_project__0" c_casadi__MX__zz_project__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
-casadi__MX__zz_project__0
-  :: MX -> Sparsity -> IO MX
-casadi__MX__zz_project__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__zz_project__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_zz_project__0 :: MXClass a => a -> Sparsity -> IO MX
-mx_zz_project__0 x = casadi__MX__zz_project__0 (castMX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MX__zz_project__1" c_casadi__MX__zz_project__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX')
-casadi__MX__zz_project__1
-  :: MX -> Sparsity -> Bool -> IO MX
-casadi__MX__zz_project__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MX__zz_project__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mx_zz_project__1 :: MXClass a => a -> Sparsity -> Bool -> IO MX
-mx_zz_project__1 x = casadi__MX__zz_project__1 (castMX x)
+         mx_attachAssert__0,
+         mx_attachAssert__1,
+         mx_binary,
+         mx_colind,
+         mx_dep__0,
+         mx_dep__1,
+         mx_dim,
+         mx_enlarge__0,
+         mx_enlarge__1,
+         mx_erase__0,
+         mx_erase__1,
+         mx_erase__2,
+         mx_erase__3,
+         mx_eye,
+         mx_getEqualityCheckingDepth,
+         mx_getFunction__0,
+         mx_getFunction__1,
+         mx_getOutput__0,
+         mx_getOutput__1,
+         mx_getTemp,
+         mx_get__0,
+         mx_get__1,
+         mx_get__2,
+         mx_get__3,
+         mx_get__4,
+         mx_get__5,
+         mx_get__6,
+         mx_get_colind,
+         mx_get_input,
+         mx_get_nz__0,
+         mx_get_nz__1,
+         mx_get_output,
+         mx_get_row,
+         mx_get_sparsity,
+         mx_grad__0,
+         mx_grad__1,
+         mx_grad__2,
+         mx_grad__3,
+         mx_grad__4,
+         mx_grad__5,
+         mx_grad__6,
+         mx_has_duplicates,
+         mx_inf__0,
+         mx_inf__1,
+         mx_inf__2,
+         mx_inf__3,
+         mx_inf__4,
+         mx_is_binary,
+         mx_is_call,
+         mx_is_column,
+         mx_is_commutative,
+         mx_is_constant,
+         mx_is_dense,
+         mx_is_empty__0,
+         mx_is_empty__1,
+         mx_is_identity,
+         mx_is_minus_one,
+         mx_is_multiplication,
+         mx_is_norm,
+         mx_is_one,
+         mx_is_op,
+         mx_is_output,
+         mx_is_regular,
+         mx_is_row,
+         mx_is_scalar__0,
+         mx_is_scalar__1,
+         mx_is_square,
+         mx_is_symbolic,
+         mx_is_transpose,
+         mx_is_tril,
+         mx_is_triu,
+         mx_is_unary,
+         mx_is_valid_input,
+         mx_is_vector,
+         mx_is_zero,
+         mx_jac__0,
+         mx_jac__1,
+         mx_jac__10,
+         mx_jac__11,
+         mx_jac__12,
+         mx_jac__13,
+         mx_jac__14,
+         mx_jac__2,
+         mx_jac__3,
+         mx_jac__4,
+         mx_jac__5,
+         mx_jac__6,
+         mx_jac__7,
+         mx_jac__8,
+         mx_jac__9,
+         mx_join_primitives,
+         mx_mapping,
+         mx_monitor,
+         mx_n_dep,
+         mx_n_out,
+         mx_n_primitives,
+         mx_name,
+         mx_nan__0,
+         mx_nan__1,
+         mx_nan__2,
+         mx_nan__3,
+         mx_nan__4,
+         mx_nnz,
+         mx_nnz_diag,
+         mx_nnz_lower,
+         mx_nnz_upper,
+         mx_numFunctions,
+         mx_numel__0,
+         mx_numel__1,
+         mx_ones__0,
+         mx_ones__1,
+         mx_ones__2,
+         mx_ones__3,
+         mx_ones__4,
+         mx_op,
+         mx_operator__minus,
+         mx_operator_casadi__Matrix_double_,
+         mx_operator_double,
+         mx_primitives,
+         mx_printme,
+         mx_resetInput,
+         mx_row,
+         mx_setEqualityCheckingDepth__0,
+         mx_setEqualityCheckingDepth__1,
+         mx_setTemp,
+         mx_set__0,
+         mx_set__1,
+         mx_set__2,
+         mx_set__3,
+         mx_set__4,
+         mx_set__5,
+         mx_set__6,
+         mx_set_nz__0,
+         mx_set_nz__1,
+         mx_size1,
+         mx_size2,
+         mx_size__0,
+         mx_size__1,
+         mx_sparsity,
+         mx_split_primitives,
+         mx_sym__0,
+         mx_sym__1,
+         mx_sym__2,
+         mx_sym__3,
+         mx_sym__4,
+         mx_sym__5,
+         mx_sym__6,
+         mx_sym__7,
+         mx_sym__8,
+         mx_tang__0,
+         mx_tang__1,
+         mx_tang__2,
+         mx_tang__3,
+         mx_tang__4,
+         mx_tang__5,
+         mx_tang__6,
+         mx_type_name,
+         mx_unary,
+         mx_zeros__0,
+         mx_zeros__1,
+         mx_zeros__2,
+         mx_zeros__3,
+         mx_zeros__4,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__0" c_casadi__MX__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__0
+  :: DM -> IO MX
+casadi__MX__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx__0 :: DM -> IO MX
+mx__0 = casadi__MX__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__1" c_casadi__MX__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__1
+  :: Vector Double -> IO MX
+casadi__MX__CONSTRUCTOR__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx__1 :: Vector Double -> IO MX
+mx__1 = casadi__MX__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__2" c_casadi__MX__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__2
+  :: MX -> IO MX
+casadi__MX__CONSTRUCTOR__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx__2 :: MX -> IO MX
+mx__2 = casadi__MX__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__3" c_casadi__MX__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__3
+  :: Double -> IO MX
+casadi__MX__CONSTRUCTOR__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx__3 :: Double -> IO MX
+mx__3 = casadi__MX__CONSTRUCTOR__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__4" c_casadi__MX__CONSTRUCTOR__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__4
+  :: Sparsity -> MX -> IO MX
+casadi__MX__CONSTRUCTOR__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx__4 :: Sparsity -> MX -> IO MX
+mx__4 = casadi__MX__CONSTRUCTOR__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__5" c_casadi__MX__CONSTRUCTOR__5
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__5
+  :: Sparsity -> IO MX
+casadi__MX__CONSTRUCTOR__5 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__5 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx__5 :: Sparsity -> IO MX
+mx__5 = casadi__MX__CONSTRUCTOR__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__6" c_casadi__MX__CONSTRUCTOR__6
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__6
+  :: Int -> Int -> IO MX
+casadi__MX__CONSTRUCTOR__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx__6 :: Int -> Int -> IO MX
+mx__6 = casadi__MX__CONSTRUCTOR__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__7" c_casadi__MX__CONSTRUCTOR__7
+  :: Ptr (Ptr StdString) -> IO (Ptr MX')
+
+casadi__MX__CONSTRUCTOR__7
+  :: IO MX
+casadi__MX__CONSTRUCTOR__7  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__CONSTRUCTOR__7 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+mx__7 :: IO MX
+mx__7 = casadi__MX__CONSTRUCTOR__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__T" c_casadi__MX__T
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__T
+  :: MX -> IO MX
+casadi__MX__T x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__T errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_T :: MXClass a => a -> IO MX
+mx_T x = casadi__MX__T (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX____nonzero__" c_casadi__MX____nonzero__
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX____nonzero__
+  :: MX -> IO Bool
+casadi__MX____nonzero__ x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX____nonzero__ errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx___nonzero__ :: MXClass a => a -> IO Bool
+mx___nonzero__ x = casadi__MX____nonzero__ (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__attachAssert__0" c_casadi__MX__attachAssert__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__attachAssert__0
+  :: MX -> MX -> IO MX
+casadi__MX__attachAssert__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__attachAssert__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_attachAssert__0 :: MXClass a => a -> MX -> IO MX
+mx_attachAssert__0 x = casadi__MX__attachAssert__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__attachAssert__1" c_casadi__MX__attachAssert__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__attachAssert__1
+  :: MX -> MX -> String -> IO MX
+casadi__MX__attachAssert__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__attachAssert__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_attachAssert__1 :: MXClass a => a -> MX -> String -> IO MX
+mx_attachAssert__1 x = casadi__MX__attachAssert__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__binary" c_casadi__MX__binary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__binary
+  :: Int -> MX -> MX -> IO MX
+casadi__MX__binary x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__binary errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_binary :: Int -> MX -> MX -> IO MX
+mx_binary = casadi__MX__binary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__colind" c_casadi__MX__colind
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
+
+casadi__MX__colind
+  :: MX -> Int -> IO Int
+casadi__MX__colind x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__colind errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_colind :: MXClass a => a -> Int -> IO Int
+mx_colind x = casadi__MX__colind (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__dep__0" c_casadi__MX__dep__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__dep__0
+  :: MX -> IO MX
+casadi__MX__dep__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__dep__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_dep__0 :: MXClass a => a -> IO MX
+mx_dep__0 x = casadi__MX__dep__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__dep__1" c_casadi__MX__dep__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi__MX__dep__1
+  :: MX -> Int -> IO MX
+casadi__MX__dep__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__dep__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_dep__1 :: MXClass a => a -> Int -> IO MX
+mx_dep__1 x = casadi__MX__dep__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__dim" c_casadi__MX__dim
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString)
+
+casadi__MX__dim
+  :: MX -> IO String
+casadi__MX__dim x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__dim errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_dim :: MXClass a => a -> IO String
+mx_dim x = casadi__MX__dim (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__enlarge__0" c_casadi__MX__enlarge__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__MX__enlarge__0
+  :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+casadi__MX__enlarge__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_enlarge__0 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+mx_enlarge__0 x = casadi__MX__enlarge__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__enlarge__1" c_casadi__MX__enlarge__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__MX__enlarge__1
+  :: MX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__MX__enlarge__1 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_enlarge__1 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+mx_enlarge__1 x = casadi__MX__enlarge__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__erase__0" c_casadi__MX__erase__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO ()
+
+casadi__MX__erase__0
+  :: MX -> Vector Int -> IO ()
+casadi__MX__erase__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__erase__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_erase__0 :: MXClass a => a -> Vector Int -> IO ()
+mx_erase__0 x = casadi__MX__erase__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__erase__1" c_casadi__MX__erase__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__MX__erase__1
+  :: MX -> Vector Int -> Bool -> IO ()
+casadi__MX__erase__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__erase__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_erase__1 :: MXClass a => a -> Vector Int -> Bool -> IO ()
+mx_erase__1 x = casadi__MX__erase__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__erase__2" c_casadi__MX__erase__2
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__MX__erase__2
+  :: MX -> Vector Int -> Vector Int -> IO ()
+casadi__MX__erase__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__erase__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_erase__2 :: MXClass a => a -> Vector Int -> Vector Int -> IO ()
+mx_erase__2 x = casadi__MX__erase__2 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__erase__3" c_casadi__MX__erase__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__MX__erase__3
+  :: MX -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__MX__erase__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__erase__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_erase__3 :: MXClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
+mx_erase__3 x = casadi__MX__erase__3 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__eye" c_casadi__MX__eye
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
+
+casadi__MX__eye
+  :: Int -> IO MX
+casadi__MX__eye x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__eye errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_eye :: Int -> IO MX
+mx_eye = casadi__MX__eye
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get__0" c_casadi__MX__get__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__MX__get__0
+  :: MX -> Bool -> IM -> IM -> IO (MX)
+casadi__MX__get__0 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get__0 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get__0/c_casadi__MX__get__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get__0 :: MXClass a => a -> Bool -> IM -> IM -> IO (MX)
+mx_get__0 x = casadi__MX__get__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get__1" c_casadi__MX__get__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__MX__get__1
+  :: MX -> Bool -> IM -> Slice -> IO (MX)
+casadi__MX__get__1 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get__1 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get__1/c_casadi__MX__get__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get__1 :: MXClass a => a -> Bool -> IM -> Slice -> IO (MX)
+mx_get__1 x = casadi__MX__get__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get__2" c_casadi__MX__get__2
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__MX__get__2
+  :: MX -> Bool -> Slice -> IM -> IO (MX)
+casadi__MX__get__2 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get__2 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get__2/c_casadi__MX__get__2" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get__2 :: MXClass a => a -> Bool -> Slice -> IM -> IO (MX)
+mx_get__2 x = casadi__MX__get__2 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get__3" c_casadi__MX__get__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__MX__get__3
+  :: MX -> Bool -> Slice -> Slice -> IO (MX)
+casadi__MX__get__3 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get__3 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get__3/c_casadi__MX__get__3" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get__3 :: MXClass a => a -> Bool -> Slice -> Slice -> IO (MX)
+mx_get__3 x = casadi__MX__get__3 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get__4" c_casadi__MX__get__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__MX__get__4
+  :: MX -> Bool -> Sparsity -> IO (MX)
+casadi__MX__get__4 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get__4 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get__4/c_casadi__MX__get__4" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get__4 :: MXClass a => a -> Bool -> Sparsity -> IO (MX)
+mx_get__4 x = casadi__MX__get__4 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get__5" c_casadi__MX__get__5
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr IM' -> IO ()
+
+casadi__MX__get__5
+  :: MX -> Bool -> IM -> IO (MX)
+casadi__MX__get__5 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get__5 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get__5/c_casadi__MX__get__5" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get__5 :: MXClass a => a -> Bool -> IM -> IO (MX)
+mx_get__5 x = casadi__MX__get__5 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get__6" c_casadi__MX__get__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__MX__get__6
+  :: MX -> Bool -> Slice -> IO (MX)
+casadi__MX__get__6 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get__6 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get__6/c_casadi__MX__get__6" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get__6 :: MXClass a => a -> Bool -> Slice -> IO (MX)
+mx_get__6 x = casadi__MX__get__6 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__getEqualityCheckingDepth" c_casadi__MX__getEqualityCheckingDepth
+  :: Ptr (Ptr StdString) -> IO CInt
+
+casadi__MX__getEqualityCheckingDepth
+  :: IO Int
+casadi__MX__getEqualityCheckingDepth  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__getEqualityCheckingDepth errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+mx_getEqualityCheckingDepth :: IO Int
+mx_getEqualityCheckingDepth = casadi__MX__getEqualityCheckingDepth
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__getFunction__0" c_casadi__MX__getFunction__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Function')
+
+casadi__MX__getFunction__0
+  :: MX -> IO Function
+casadi__MX__getFunction__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__getFunction__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_getFunction__0 :: MXClass a => a -> IO Function
+mx_getFunction__0 x = casadi__MX__getFunction__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__getFunction__1" c_casadi__MX__getFunction__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr Function')
+
+casadi__MX__getFunction__1
+  :: MX -> Int -> IO Function
+casadi__MX__getFunction__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__getFunction__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_getFunction__1 :: MXClass a => a -> Int -> IO Function
+mx_getFunction__1 x = casadi__MX__getFunction__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__getOutput__0" c_casadi__MX__getOutput__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__getOutput__0
+  :: MX -> IO MX
+casadi__MX__getOutput__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__getOutput__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_getOutput__0 :: MXClass a => a -> IO MX
+mx_getOutput__0 x = casadi__MX__getOutput__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__getOutput__1" c_casadi__MX__getOutput__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi__MX__getOutput__1
+  :: MX -> Int -> IO MX
+casadi__MX__getOutput__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__getOutput__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_getOutput__1 :: MXClass a => a -> Int -> IO MX
+mx_getOutput__1 x = casadi__MX__getOutput__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__getTemp" c_casadi__MX__getTemp
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__getTemp
+  :: MX -> IO Int
+casadi__MX__getTemp x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__getTemp errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_getTemp :: MXClass a => a -> IO Int
+mx_getTemp x = casadi__MX__getTemp (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get_colind" c_casadi__MX__get_colind
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt))
+
+casadi__MX__get_colind
+  :: MX -> IO (Vector Int)
+casadi__MX__get_colind x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get_colind errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_get_colind :: MXClass a => a -> IO (Vector Int)
+mx_get_colind x = casadi__MX__get_colind (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get_input" c_casadi__MX__get_input
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__MX__get_input
+  :: Function -> IO (Vector MX)
+casadi__MX__get_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_get_input :: Function -> IO (Vector MX)
+mx_get_input = casadi__MX__get_input
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get_nz__0" c_casadi__MX__get_nz__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr IM' -> IO ()
+
+casadi__MX__get_nz__0
+  :: MX -> Bool -> IM -> IO (MX)
+casadi__MX__get_nz__0 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get_nz__0 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get_nz__0/c_casadi__MX__get_nz__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get_nz__0 :: MXClass a => a -> Bool -> IM -> IO (MX)
+mx_get_nz__0 x = casadi__MX__get_nz__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get_nz__1" c_casadi__MX__get_nz__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (Ptr MX') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__MX__get_nz__1
+  :: MX -> Bool -> Slice -> IO (MX)
+casadi__MX__get_nz__1 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get_nz__1 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__MX__get_nz__1/c_casadi__MX__get_nz__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+mx_get_nz__1 :: MXClass a => a -> Bool -> Slice -> IO (MX)
+mx_get_nz__1 x = casadi__MX__get_nz__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get_output" c_casadi__MX__get_output
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__get_output
+  :: MX -> IO Int
+casadi__MX__get_output x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get_output errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_get_output :: MXClass a => a -> IO Int
+mx_get_output x = casadi__MX__get_output (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get_row" c_casadi__MX__get_row
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt))
+
+casadi__MX__get_row
+  :: MX -> IO (Vector Int)
+casadi__MX__get_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_get_row :: MXClass a => a -> IO (Vector Int)
+mx_get_row x = casadi__MX__get_row (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__get_sparsity" c_casadi__MX__get_sparsity
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity')
+
+casadi__MX__get_sparsity
+  :: MX -> IO Sparsity
+casadi__MX__get_sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__get_sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_get_sparsity :: MXClass a => a -> IO Sparsity
+mx_get_sparsity x = casadi__MX__get_sparsity (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__grad__0" c_casadi__MX__grad__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__grad__0
+  :: Function -> String -> String -> IO MX
+casadi__MX__grad__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__grad__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_grad__0 :: Function -> String -> String -> IO MX
+mx_grad__0 = casadi__MX__grad__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__grad__1" c_casadi__MX__grad__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__grad__1
+  :: Function -> Int -> String -> IO MX
+casadi__MX__grad__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__grad__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_grad__1 :: Function -> Int -> String -> IO MX
+mx_grad__1 = casadi__MX__grad__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__grad__2" c_casadi__MX__grad__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__grad__2
+  :: Function -> String -> IO MX
+casadi__MX__grad__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__grad__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_grad__2 :: Function -> String -> IO MX
+mx_grad__2 = casadi__MX__grad__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__grad__3" c_casadi__MX__grad__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__MX__grad__3
+  :: Function -> String -> Int -> IO MX
+casadi__MX__grad__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__grad__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_grad__3 :: Function -> String -> Int -> IO MX
+mx_grad__3 = casadi__MX__grad__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__grad__4" c_casadi__MX__grad__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MX')
+
+casadi__MX__grad__4
+  :: Function -> IO MX
+casadi__MX__grad__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__grad__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_grad__4 :: Function -> IO MX
+mx_grad__4 = casadi__MX__grad__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__grad__5" c_casadi__MX__grad__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MX')
+
+casadi__MX__grad__5
+  :: Function -> Int -> IO MX
+casadi__MX__grad__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__grad__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_grad__5 :: Function -> Int -> IO MX
+mx_grad__5 = casadi__MX__grad__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__grad__6" c_casadi__MX__grad__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__grad__6
+  :: Function -> Int -> Int -> IO MX
+casadi__MX__grad__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__grad__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_grad__6 :: Function -> Int -> Int -> IO MX
+mx_grad__6 = casadi__MX__grad__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__has_duplicates" c_casadi__MX__has_duplicates
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__has_duplicates
+  :: MX -> IO Bool
+casadi__MX__has_duplicates x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__has_duplicates errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_has_duplicates :: MXClass a => a -> IO Bool
+mx_has_duplicates x = casadi__MX__has_duplicates (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__inf__0" c_casadi__MX__inf__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
+
+casadi__MX__inf__0
+  :: (Int, Int) -> IO MX
+casadi__MX__inf__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__inf__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_inf__0 :: (Int, Int) -> IO MX
+mx_inf__0 = casadi__MX__inf__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__inf__1" c_casadi__MX__inf__1
+  :: Ptr (Ptr StdString) -> IO (Ptr MX')
+
+casadi__MX__inf__1
+  :: IO MX
+casadi__MX__inf__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__inf__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+mx_inf__1 :: IO MX
+mx_inf__1 = casadi__MX__inf__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__inf__2" c_casadi__MX__inf__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
+
+casadi__MX__inf__2
+  :: Int -> IO MX
+casadi__MX__inf__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__inf__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_inf__2 :: Int -> IO MX
+mx_inf__2 = casadi__MX__inf__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__inf__3" c_casadi__MX__inf__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__inf__3
+  :: Int -> Int -> IO MX
+casadi__MX__inf__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__inf__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_inf__3 :: Int -> Int -> IO MX
+mx_inf__3 = casadi__MX__inf__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__inf__4" c_casadi__MX__inf__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi__MX__inf__4
+  :: Sparsity -> IO MX
+casadi__MX__inf__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__inf__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_inf__4 :: Sparsity -> IO MX
+mx_inf__4 = casadi__MX__inf__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_binary" c_casadi__MX__is_binary
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_binary
+  :: MX -> IO Bool
+casadi__MX__is_binary x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_binary errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_binary :: MXClass a => a -> IO Bool
+mx_is_binary x = casadi__MX__is_binary (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_call" c_casadi__MX__is_call
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_call
+  :: MX -> IO Bool
+casadi__MX__is_call x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_call errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_call :: MXClass a => a -> IO Bool
+mx_is_call x = casadi__MX__is_call (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_column" c_casadi__MX__is_column
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_column
+  :: MX -> IO Bool
+casadi__MX__is_column x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_column errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_column :: MXClass a => a -> IO Bool
+mx_is_column x = casadi__MX__is_column (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_commutative" c_casadi__MX__is_commutative
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_commutative
+  :: MX -> IO Bool
+casadi__MX__is_commutative x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_commutative errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_commutative :: MXClass a => a -> IO Bool
+mx_is_commutative x = casadi__MX__is_commutative (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_constant" c_casadi__MX__is_constant
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_constant
+  :: MX -> IO Bool
+casadi__MX__is_constant x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_constant errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_constant :: MXClass a => a -> IO Bool
+mx_is_constant x = casadi__MX__is_constant (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_dense" c_casadi__MX__is_dense
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_dense
+  :: MX -> IO Bool
+casadi__MX__is_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_dense :: MXClass a => a -> IO Bool
+mx_is_dense x = casadi__MX__is_dense (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_empty__0" c_casadi__MX__is_empty__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_empty__0
+  :: MX -> IO Bool
+casadi__MX__is_empty__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_empty__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_empty__0 :: MXClass a => a -> IO Bool
+mx_is_empty__0 x = casadi__MX__is_empty__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_empty__1" c_casadi__MX__is_empty__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
+
+casadi__MX__is_empty__1
+  :: MX -> Bool -> IO Bool
+casadi__MX__is_empty__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_empty__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_empty__1 :: MXClass a => a -> Bool -> IO Bool
+mx_is_empty__1 x = casadi__MX__is_empty__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_identity" c_casadi__MX__is_identity
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_identity
+  :: MX -> IO Bool
+casadi__MX__is_identity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_identity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_identity :: MXClass a => a -> IO Bool
+mx_is_identity x = casadi__MX__is_identity (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_minus_one" c_casadi__MX__is_minus_one
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_minus_one
+  :: MX -> IO Bool
+casadi__MX__is_minus_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_minus_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_minus_one :: MXClass a => a -> IO Bool
+mx_is_minus_one x = casadi__MX__is_minus_one (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_multiplication" c_casadi__MX__is_multiplication
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_multiplication
+  :: MX -> IO Bool
+casadi__MX__is_multiplication x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_multiplication errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_multiplication :: MXClass a => a -> IO Bool
+mx_is_multiplication x = casadi__MX__is_multiplication (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_norm" c_casadi__MX__is_norm
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_norm
+  :: MX -> IO Bool
+casadi__MX__is_norm x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_norm errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_norm :: MXClass a => a -> IO Bool
+mx_is_norm x = casadi__MX__is_norm (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_one" c_casadi__MX__is_one
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_one
+  :: MX -> IO Bool
+casadi__MX__is_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_one :: MXClass a => a -> IO Bool
+mx_is_one x = casadi__MX__is_one (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_op" c_casadi__MX__is_op
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
+
+casadi__MX__is_op
+  :: MX -> Int -> IO Bool
+casadi__MX__is_op x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_op errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_op :: MXClass a => a -> Int -> IO Bool
+mx_is_op x = casadi__MX__is_op (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_output" c_casadi__MX__is_output
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_output
+  :: MX -> IO Bool
+casadi__MX__is_output x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_output errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_output :: MXClass a => a -> IO Bool
+mx_is_output x = casadi__MX__is_output (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_regular" c_casadi__MX__is_regular
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_regular
+  :: MX -> IO Bool
+casadi__MX__is_regular x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_regular errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_regular :: MXClass a => a -> IO Bool
+mx_is_regular x = casadi__MX__is_regular (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_row" c_casadi__MX__is_row
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_row
+  :: MX -> IO Bool
+casadi__MX__is_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_row :: MXClass a => a -> IO Bool
+mx_is_row x = casadi__MX__is_row (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_scalar__0" c_casadi__MX__is_scalar__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_scalar__0
+  :: MX -> IO Bool
+casadi__MX__is_scalar__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_scalar__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_scalar__0 :: MXClass a => a -> IO Bool
+mx_is_scalar__0 x = casadi__MX__is_scalar__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_scalar__1" c_casadi__MX__is_scalar__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
+
+casadi__MX__is_scalar__1
+  :: MX -> Bool -> IO Bool
+casadi__MX__is_scalar__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_scalar__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_scalar__1 :: MXClass a => a -> Bool -> IO Bool
+mx_is_scalar__1 x = casadi__MX__is_scalar__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_square" c_casadi__MX__is_square
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_square
+  :: MX -> IO Bool
+casadi__MX__is_square x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_square errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_square :: MXClass a => a -> IO Bool
+mx_is_square x = casadi__MX__is_square (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_symbolic" c_casadi__MX__is_symbolic
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_symbolic
+  :: MX -> IO Bool
+casadi__MX__is_symbolic x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_symbolic errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_symbolic :: MXClass a => a -> IO Bool
+mx_is_symbolic x = casadi__MX__is_symbolic (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_transpose" c_casadi__MX__is_transpose
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_transpose
+  :: MX -> IO Bool
+casadi__MX__is_transpose x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_transpose errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_transpose :: MXClass a => a -> IO Bool
+mx_is_transpose x = casadi__MX__is_transpose (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_tril" c_casadi__MX__is_tril
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_tril
+  :: MX -> IO Bool
+casadi__MX__is_tril x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_tril errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_tril :: MXClass a => a -> IO Bool
+mx_is_tril x = casadi__MX__is_tril (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_triu" c_casadi__MX__is_triu
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_triu
+  :: MX -> IO Bool
+casadi__MX__is_triu x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_triu errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_triu :: MXClass a => a -> IO Bool
+mx_is_triu x = casadi__MX__is_triu (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_unary" c_casadi__MX__is_unary
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_unary
+  :: MX -> IO Bool
+casadi__MX__is_unary x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_unary errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_unary :: MXClass a => a -> IO Bool
+mx_is_unary x = casadi__MX__is_unary (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_valid_input" c_casadi__MX__is_valid_input
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_valid_input
+  :: MX -> IO Bool
+casadi__MX__is_valid_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_valid_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_valid_input :: MXClass a => a -> IO Bool
+mx_is_valid_input x = casadi__MX__is_valid_input (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_vector" c_casadi__MX__is_vector
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_vector
+  :: MX -> IO Bool
+casadi__MX__is_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_vector :: MXClass a => a -> IO Bool
+mx_is_vector x = casadi__MX__is_vector (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__is_zero" c_casadi__MX__is_zero
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__is_zero
+  :: MX -> IO Bool
+casadi__MX__is_zero x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__is_zero errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_is_zero :: MXClass a => a -> IO Bool
+mx_is_zero x = casadi__MX__is_zero (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__0" c_casadi__MX__jac__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__jac__0
+  :: Function -> String -> String -> IO MX
+casadi__MX__jac__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__0 :: Function -> String -> String -> IO MX
+mx_jac__0 = casadi__MX__jac__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__1" c_casadi__MX__jac__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__1
+  :: Function -> String -> String -> Bool -> IO MX
+casadi__MX__jac__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__1 :: Function -> String -> String -> Bool -> IO MX
+mx_jac__1 = casadi__MX__jac__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__2" c_casadi__MX__jac__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__2
+  :: Function -> String -> String -> Bool -> Bool -> IO MX
+casadi__MX__jac__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__2 :: Function -> String -> String -> Bool -> Bool -> IO MX
+mx_jac__2 = casadi__MX__jac__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__3" c_casadi__MX__jac__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__jac__3
+  :: Function -> Int -> String -> IO MX
+casadi__MX__jac__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__3 :: Function -> Int -> String -> IO MX
+mx_jac__3 = casadi__MX__jac__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__4" c_casadi__MX__jac__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__4
+  :: Function -> Int -> String -> Bool -> IO MX
+casadi__MX__jac__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__4 :: Function -> Int -> String -> Bool -> IO MX
+mx_jac__4 = casadi__MX__jac__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__5" c_casadi__MX__jac__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__5
+  :: Function -> Int -> String -> Bool -> Bool -> IO MX
+casadi__MX__jac__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__5 :: Function -> Int -> String -> Bool -> Bool -> IO MX
+mx_jac__5 = casadi__MX__jac__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__6" c_casadi__MX__jac__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__jac__6
+  :: Function -> String -> IO MX
+casadi__MX__jac__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__6 :: Function -> String -> IO MX
+mx_jac__6 = casadi__MX__jac__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__7" c_casadi__MX__jac__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__7
+  :: Function -> String -> Int -> IO MX
+casadi__MX__jac__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__7 :: Function -> String -> Int -> IO MX
+mx_jac__7 = casadi__MX__jac__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__8" c_casadi__MX__jac__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__8
+  :: Function -> String -> Int -> Bool -> IO MX
+casadi__MX__jac__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__8 :: Function -> String -> Int -> Bool -> IO MX
+mx_jac__8 = casadi__MX__jac__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__9" c_casadi__MX__jac__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__9
+  :: Function -> String -> Int -> Bool -> Bool -> IO MX
+casadi__MX__jac__9 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__9 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__9 :: Function -> String -> Int -> Bool -> Bool -> IO MX
+mx_jac__9 = casadi__MX__jac__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__10" c_casadi__MX__jac__10
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MX')
+
+casadi__MX__jac__10
+  :: Function -> IO MX
+casadi__MX__jac__10 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__10 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__10 :: Function -> IO MX
+mx_jac__10 = casadi__MX__jac__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__11" c_casadi__MX__jac__11
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__11
+  :: Function -> Int -> IO MX
+casadi__MX__jac__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__11 :: Function -> Int -> IO MX
+mx_jac__11 = casadi__MX__jac__11
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__12" c_casadi__MX__jac__12
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__12
+  :: Function -> Int -> Int -> IO MX
+casadi__MX__jac__12 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__12 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__12 :: Function -> Int -> Int -> IO MX
+mx_jac__12 = casadi__MX__jac__12
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__13" c_casadi__MX__jac__13
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__13
+  :: Function -> Int -> Int -> Bool -> IO MX
+casadi__MX__jac__13 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__13 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__13 :: Function -> Int -> Int -> Bool -> IO MX
+mx_jac__13 = casadi__MX__jac__13
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__jac__14" c_casadi__MX__jac__14
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__jac__14
+  :: Function -> Int -> Int -> Bool -> Bool -> IO MX
+casadi__MX__jac__14 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__jac__14 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_jac__14 :: Function -> Int -> Int -> Bool -> Bool -> IO MX
+mx_jac__14 = casadi__MX__jac__14
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__join_primitives" c_casadi__MX__join_primitives
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi__MX__join_primitives
+  :: MX -> Vector MX -> IO MX
+casadi__MX__join_primitives x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__join_primitives errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_join_primitives :: MXClass a => a -> Vector MX -> IO MX
+mx_join_primitives x = casadi__MX__join_primitives (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__mapping" c_casadi__MX__mapping
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr IM')
+
+casadi__MX__mapping
+  :: MX -> IO IM
+casadi__MX__mapping x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__mapping errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_mapping :: MXClass a => a -> IO IM
+mx_mapping x = casadi__MX__mapping (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__monitor" c_casadi__MX__monitor
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__monitor
+  :: MX -> String -> IO MX
+casadi__MX__monitor x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__monitor errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_monitor :: MXClass a => a -> String -> IO MX
+mx_monitor x = casadi__MX__monitor (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__n_dep" c_casadi__MX__n_dep
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__n_dep
+  :: MX -> IO Int
+casadi__MX__n_dep x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__n_dep errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_n_dep :: MXClass a => a -> IO Int
+mx_n_dep x = casadi__MX__n_dep (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__n_out" c_casadi__MX__n_out
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__n_out
+  :: MX -> IO Int
+casadi__MX__n_out x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__n_out errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_n_out :: MXClass a => a -> IO Int
+mx_n_out x = casadi__MX__n_out (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__n_primitives" c_casadi__MX__n_primitives
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__n_primitives
+  :: MX -> IO Int
+casadi__MX__n_primitives x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__n_primitives errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_n_primitives :: MXClass a => a -> IO Int
+mx_n_primitives x = casadi__MX__n_primitives (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__name" c_casadi__MX__name
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString)
+
+casadi__MX__name
+  :: MX -> IO String
+casadi__MX__name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_name :: MXClass a => a -> IO String
+mx_name x = casadi__MX__name (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nan__0" c_casadi__MX__nan__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
+
+casadi__MX__nan__0
+  :: (Int, Int) -> IO MX
+casadi__MX__nan__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nan__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nan__0 :: (Int, Int) -> IO MX
+mx_nan__0 = casadi__MX__nan__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nan__1" c_casadi__MX__nan__1
+  :: Ptr (Ptr StdString) -> IO (Ptr MX')
+
+casadi__MX__nan__1
+  :: IO MX
+casadi__MX__nan__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nan__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nan__1 :: IO MX
+mx_nan__1 = casadi__MX__nan__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nan__2" c_casadi__MX__nan__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
+
+casadi__MX__nan__2
+  :: Int -> IO MX
+casadi__MX__nan__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nan__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nan__2 :: Int -> IO MX
+mx_nan__2 = casadi__MX__nan__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nan__3" c_casadi__MX__nan__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__nan__3
+  :: Int -> Int -> IO MX
+casadi__MX__nan__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nan__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nan__3 :: Int -> Int -> IO MX
+mx_nan__3 = casadi__MX__nan__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nan__4" c_casadi__MX__nan__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi__MX__nan__4
+  :: Sparsity -> IO MX
+casadi__MX__nan__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nan__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nan__4 :: Sparsity -> IO MX
+mx_nan__4 = casadi__MX__nan__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nnz" c_casadi__MX__nnz
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__nnz
+  :: MX -> IO Int
+casadi__MX__nnz x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nnz errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nnz :: MXClass a => a -> IO Int
+mx_nnz x = casadi__MX__nnz (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nnz_diag" c_casadi__MX__nnz_diag
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__nnz_diag
+  :: MX -> IO Int
+casadi__MX__nnz_diag x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nnz_diag errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nnz_diag :: MXClass a => a -> IO Int
+mx_nnz_diag x = casadi__MX__nnz_diag (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nnz_lower" c_casadi__MX__nnz_lower
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__nnz_lower
+  :: MX -> IO Int
+casadi__MX__nnz_lower x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nnz_lower errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nnz_lower :: MXClass a => a -> IO Int
+mx_nnz_lower x = casadi__MX__nnz_lower (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__nnz_upper" c_casadi__MX__nnz_upper
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__nnz_upper
+  :: MX -> IO Int
+casadi__MX__nnz_upper x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__nnz_upper errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_nnz_upper :: MXClass a => a -> IO Int
+mx_nnz_upper x = casadi__MX__nnz_upper (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__numFunctions" c_casadi__MX__numFunctions
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__numFunctions
+  :: MX -> IO Int
+casadi__MX__numFunctions x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__numFunctions errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_numFunctions :: MXClass a => a -> IO Int
+mx_numFunctions x = casadi__MX__numFunctions (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__numel__0" c_casadi__MX__numel__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
+
+casadi__MX__numel__0
+  :: MX -> Int -> IO Int
+casadi__MX__numel__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__numel__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_numel__0 :: MXClass a => a -> Int -> IO Int
+mx_numel__0 x = casadi__MX__numel__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__numel__1" c_casadi__MX__numel__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__numel__1
+  :: MX -> IO Int
+casadi__MX__numel__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__numel__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_numel__1 :: MXClass a => a -> IO Int
+mx_numel__1 x = casadi__MX__numel__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__ones__0" c_casadi__MX__ones__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
+
+casadi__MX__ones__0
+  :: (Int, Int) -> IO MX
+casadi__MX__ones__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__ones__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_ones__0 :: (Int, Int) -> IO MX
+mx_ones__0 = casadi__MX__ones__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__ones__1" c_casadi__MX__ones__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi__MX__ones__1
+  :: Sparsity -> IO MX
+casadi__MX__ones__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__ones__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_ones__1 :: Sparsity -> IO MX
+mx_ones__1 = casadi__MX__ones__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__ones__2" c_casadi__MX__ones__2
+  :: Ptr (Ptr StdString) -> IO (Ptr MX')
+
+casadi__MX__ones__2
+  :: IO MX
+casadi__MX__ones__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__ones__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+mx_ones__2 :: IO MX
+mx_ones__2 = casadi__MX__ones__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__ones__3" c_casadi__MX__ones__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
+
+casadi__MX__ones__3
+  :: Int -> IO MX
+casadi__MX__ones__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__ones__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_ones__3 :: Int -> IO MX
+mx_ones__3 = casadi__MX__ones__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__ones__4" c_casadi__MX__ones__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__ones__4
+  :: Int -> Int -> IO MX
+casadi__MX__ones__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__ones__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_ones__4 :: Int -> Int -> IO MX
+mx_ones__4 = casadi__MX__ones__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__op" c_casadi__MX__op
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__op
+  :: MX -> IO Int
+casadi__MX__op x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__op errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_op :: MXClass a => a -> IO Int
+mx_op x = casadi__MX__op (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__operator__minus" c_casadi__MX__operator__minus
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__operator__minus
+  :: MX -> IO MX
+casadi__MX__operator__minus x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__operator__minus errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_operator__minus :: MXClass a => a -> IO MX
+mx_operator__minus x = casadi__MX__operator__minus (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__operator_casadi__Matrix_double_" c_casadi__MX__operator_casadi__Matrix_double_
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr DM')
+
+casadi__MX__operator_casadi__Matrix_double_
+  :: MX -> IO DM
+casadi__MX__operator_casadi__Matrix_double_ x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__operator_casadi__Matrix_double_ errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_operator_casadi__Matrix_double_ :: MXClass a => a -> IO DM
+mx_operator_casadi__Matrix_double_ x = casadi__MX__operator_casadi__Matrix_double_ (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__operator_double" c_casadi__MX__operator_double
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CDouble
+
+casadi__MX__operator_double
+  :: MX -> IO Double
+casadi__MX__operator_double x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__operator_double errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_operator_double :: MXClass a => a -> IO Double
+mx_operator_double x = casadi__MX__operator_double (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__primitives" c_casadi__MX__primitives
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__MX__primitives
+  :: MX -> IO (Vector MX)
+casadi__MX__primitives x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__primitives errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_primitives :: MXClass a => a -> IO (Vector MX)
+mx_primitives x = casadi__MX__primitives (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__printme" c_casadi__MX__printme
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__printme
+  :: MX -> MX -> IO MX
+casadi__MX__printme x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__printme errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_printme :: MXClass a => a -> MX -> IO MX
+mx_printme x = casadi__MX__printme (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__resetInput" c_casadi__MX__resetInput
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
+
+casadi__MX__resetInput
+  :: MX -> IO ()
+casadi__MX__resetInput x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__resetInput errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_resetInput :: MXClass a => a -> IO ()
+mx_resetInput x = casadi__MX__resetInput (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__row" c_casadi__MX__row
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
+
+casadi__MX__row
+  :: MX -> Int -> IO Int
+casadi__MX__row x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__row errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_row :: MXClass a => a -> Int -> IO Int
+mx_row x = casadi__MX__row (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set__0" c_casadi__MX__set__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__MX__set__0
+  :: MX -> MX -> Bool -> IM -> IM -> IO ()
+casadi__MX__set__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set__0 :: MXClass a => a -> MX -> Bool -> IM -> IM -> IO ()
+mx_set__0 x = casadi__MX__set__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set__1" c_casadi__MX__set__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__MX__set__1
+  :: MX -> MX -> Bool -> IM -> Slice -> IO ()
+casadi__MX__set__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set__1 :: MXClass a => a -> MX -> Bool -> IM -> Slice -> IO ()
+mx_set__1 x = casadi__MX__set__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set__2" c_casadi__MX__set__2
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__MX__set__2
+  :: MX -> MX -> Bool -> Slice -> IM -> IO ()
+casadi__MX__set__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set__2 :: MXClass a => a -> MX -> Bool -> Slice -> IM -> IO ()
+mx_set__2 x = casadi__MX__set__2 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set__3" c_casadi__MX__set__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__MX__set__3
+  :: MX -> MX -> Bool -> Slice -> Slice -> IO ()
+casadi__MX__set__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO ()
+mx_set__3 x = casadi__MX__set__3 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set__4" c_casadi__MX__set__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__MX__set__4
+  :: MX -> MX -> Bool -> Sparsity -> IO ()
+casadi__MX__set__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO ()
+mx_set__4 x = casadi__MX__set__4 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set__5" c_casadi__MX__set__5
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IM' -> IO ()
+
+casadi__MX__set__5
+  :: MX -> MX -> Bool -> IM -> IO ()
+casadi__MX__set__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set__5 :: MXClass a => a -> MX -> Bool -> IM -> IO ()
+mx_set__5 x = casadi__MX__set__5 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set__6" c_casadi__MX__set__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__MX__set__6
+  :: MX -> MX -> Bool -> Slice -> IO ()
+casadi__MX__set__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
+mx_set__6 x = casadi__MX__set__6 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__0" c_casadi__MX__setEqualityCheckingDepth__0
+  :: Ptr (Ptr StdString) -> IO ()
+
+casadi__MX__setEqualityCheckingDepth__0
+  :: IO ()
+casadi__MX__setEqualityCheckingDepth__0  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__setEqualityCheckingDepth__0 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ()
+
+
+
+-- classy wrapper
+mx_setEqualityCheckingDepth__0 :: IO ()
+mx_setEqualityCheckingDepth__0 = casadi__MX__setEqualityCheckingDepth__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__1" c_casadi__MX__setEqualityCheckingDepth__1
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__MX__setEqualityCheckingDepth__1
+  :: Int -> IO ()
+casadi__MX__setEqualityCheckingDepth__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__setEqualityCheckingDepth__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_setEqualityCheckingDepth__1 :: Int -> IO ()
+mx_setEqualityCheckingDepth__1 = casadi__MX__setEqualityCheckingDepth__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__setTemp" c_casadi__MX__setTemp
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO ()
+
+casadi__MX__setTemp
+  :: MX -> Int -> IO ()
+casadi__MX__setTemp x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__setTemp errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_setTemp :: MXClass a => a -> Int -> IO ()
+mx_setTemp x = casadi__MX__setTemp (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set_nz__0" c_casadi__MX__set_nz__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IM' -> IO ()
+
+casadi__MX__set_nz__0
+  :: MX -> MX -> Bool -> IM -> IO ()
+casadi__MX__set_nz__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set_nz__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set_nz__0 :: MXClass a => a -> MX -> Bool -> IM -> IO ()
+mx_set_nz__0 x = casadi__MX__set_nz__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__set_nz__1" c_casadi__MX__set_nz__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__MX__set_nz__1
+  :: MX -> MX -> Bool -> Slice -> IO ()
+casadi__MX__set_nz__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__set_nz__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+mx_set_nz__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
+mx_set_nz__1 x = casadi__MX__set_nz__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__size__0" c_casadi__MX__size__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
+
+casadi__MX__size__0
+  :: MX -> Int -> IO Int
+casadi__MX__size__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__size__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_size__0 :: MXClass a => a -> Int -> IO Int
+mx_size__0 x = casadi__MX__size__0 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__size__1" c_casadi__MX__size__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdPair CInt CInt))
+
+casadi__MX__size__1
+  :: MX -> IO (Int, Int)
+casadi__MX__size__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__size__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_size__1 :: MXClass a => a -> IO (Int, Int)
+mx_size__1 x = casadi__MX__size__1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__size1" c_casadi__MX__size1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__size1
+  :: MX -> IO Int
+casadi__MX__size1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__size1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_size1 :: MXClass a => a -> IO Int
+mx_size1 x = casadi__MX__size1 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__size2" c_casadi__MX__size2
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi__MX__size2
+  :: MX -> IO Int
+casadi__MX__size2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__size2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_size2 :: MXClass a => a -> IO Int
+mx_size2 x = casadi__MX__size2 (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sparsity" c_casadi__MX__sparsity
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity')
+
+casadi__MX__sparsity
+  :: MX -> IO Sparsity
+casadi__MX__sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sparsity :: MXClass a => a -> IO Sparsity
+mx_sparsity x = casadi__MX__sparsity (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__split_primitives" c_casadi__MX__split_primitives
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__MX__split_primitives
+  :: MX -> MX -> IO (Vector MX)
+casadi__MX__split_primitives x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__split_primitives errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_split_primitives :: MXClass a => a -> MX -> IO (Vector MX)
+mx_split_primitives x = casadi__MX__split_primitives (castMX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__0" c_casadi__MX__sym__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+
+casadi__MX__sym__0
+  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
+casadi__MX__sym__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
+mx_sym__0 = casadi__MX__sym__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__1" c_casadi__MX__sym__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+
+casadi__MX__sym__1
+  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
+casadi__MX__sym__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
+mx_sym__1 = casadi__MX__sym__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__2" c_casadi__MX__sym__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__MX__sym__2
+  :: String -> Int -> Int -> Int -> IO (Vector MX)
+casadi__MX__sym__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector MX)
+mx_sym__2 = casadi__MX__sym__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__3" c_casadi__MX__sym__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi__MX__sym__3
+  :: String -> Sparsity -> Int -> IO (Vector MX)
+casadi__MX__sym__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__3 :: String -> Sparsity -> Int -> IO (Vector MX)
+mx_sym__3 = casadi__MX__sym__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__4" c_casadi__MX__sym__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi__MX__sym__4
+  :: String -> Sparsity -> IO MX
+casadi__MX__sym__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__4 :: String -> Sparsity -> IO MX
+mx_sym__4 = casadi__MX__sym__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__5" c_casadi__MX__sym__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
+
+casadi__MX__sym__5
+  :: String -> (Int, Int) -> IO MX
+casadi__MX__sym__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__5 :: String -> (Int, Int) -> IO MX
+mx_sym__5 = casadi__MX__sym__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__6" c_casadi__MX__sym__6
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__sym__6
+  :: String -> IO MX
+casadi__MX__sym__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__6 :: String -> IO MX
+mx_sym__6 = casadi__MX__sym__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__7" c_casadi__MX__sym__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__MX__sym__7
+  :: String -> Int -> IO MX
+casadi__MX__sym__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__7 :: String -> Int -> IO MX
+mx_sym__7 = casadi__MX__sym__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__sym__8" c_casadi__MX__sym__8
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__sym__8
+  :: String -> Int -> Int -> IO MX
+casadi__MX__sym__8 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__sym__8 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_sym__8 :: String -> Int -> Int -> IO MX
+mx_sym__8 = casadi__MX__sym__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__tang__0" c_casadi__MX__tang__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__tang__0
+  :: Function -> String -> String -> IO MX
+casadi__MX__tang__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__tang__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_tang__0 :: Function -> String -> String -> IO MX
+mx_tang__0 = casadi__MX__tang__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__tang__1" c_casadi__MX__tang__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__tang__1
+  :: Function -> Int -> String -> IO MX
+casadi__MX__tang__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__tang__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_tang__1 :: Function -> Int -> String -> IO MX
+mx_tang__1 = casadi__MX__tang__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__tang__2" c_casadi__MX__tang__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MX')
+
+casadi__MX__tang__2
+  :: Function -> String -> IO MX
+casadi__MX__tang__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__tang__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_tang__2 :: Function -> String -> IO MX
+mx_tang__2 = casadi__MX__tang__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__tang__3" c_casadi__MX__tang__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr MX')
+
+casadi__MX__tang__3
+  :: Function -> String -> Int -> IO MX
+casadi__MX__tang__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__tang__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_tang__3 :: Function -> String -> Int -> IO MX
+mx_tang__3 = casadi__MX__tang__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__tang__4" c_casadi__MX__tang__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MX')
+
+casadi__MX__tang__4
+  :: Function -> IO MX
+casadi__MX__tang__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__tang__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_tang__4 :: Function -> IO MX
+mx_tang__4 = casadi__MX__tang__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__tang__5" c_casadi__MX__tang__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MX')
+
+casadi__MX__tang__5
+  :: Function -> Int -> IO MX
+casadi__MX__tang__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__tang__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_tang__5 :: Function -> Int -> IO MX
+mx_tang__5 = casadi__MX__tang__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__tang__6" c_casadi__MX__tang__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__tang__6
+  :: Function -> Int -> Int -> IO MX
+casadi__MX__tang__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__tang__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_tang__6 :: Function -> Int -> Int -> IO MX
+mx_tang__6 = casadi__MX__tang__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__type_name" c_casadi__MX__type_name
+  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
+casadi__MX__type_name
+  :: IO String
+casadi__MX__type_name  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__type_name errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+mx_type_name :: IO String
+mx_type_name = casadi__MX__type_name
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__unary" c_casadi__MX__unary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> IO (Ptr MX')
+
+casadi__MX__unary
+  :: Int -> MX -> IO MX
+casadi__MX__unary x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__unary errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_unary :: Int -> MX -> IO MX
+mx_unary = casadi__MX__unary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__zeros__0" c_casadi__MX__zeros__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
+
+casadi__MX__zeros__0
+  :: (Int, Int) -> IO MX
+casadi__MX__zeros__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__zeros__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_zeros__0 :: (Int, Int) -> IO MX
+mx_zeros__0 = casadi__MX__zeros__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__zeros__1" c_casadi__MX__zeros__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi__MX__zeros__1
+  :: Sparsity -> IO MX
+casadi__MX__zeros__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__zeros__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_zeros__1 :: Sparsity -> IO MX
+mx_zeros__1 = casadi__MX__zeros__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__zeros__2" c_casadi__MX__zeros__2
+  :: Ptr (Ptr StdString) -> IO (Ptr MX')
+
+casadi__MX__zeros__2
+  :: IO MX
+casadi__MX__zeros__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__zeros__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+mx_zeros__2 :: IO MX
+mx_zeros__2 = casadi__MX__zeros__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__zeros__3" c_casadi__MX__zeros__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX')
+
+casadi__MX__zeros__3
+  :: Int -> IO MX
+casadi__MX__zeros__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__zeros__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_zeros__3 :: Int -> IO MX
+mx_zeros__3 = casadi__MX__zeros__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__MX__zeros__4" c_casadi__MX__zeros__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX')
+
+casadi__MX__zeros__4
+  :: Int -> Int -> IO MX
+casadi__MX__zeros__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__MX__zeros__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+mx_zeros__4 :: Int -> Int -> IO MX
+mx_zeros__4 = casadi__MX__zeros__4
 
diff --git a/Casadi/Core/Classes/MXFunction.hs b/Casadi/Core/Classes/MXFunction.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/MXFunction.hs
+++ /dev/null
@@ -1,1165 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.MXFunction
-       (
-         MXFunction,
-         MXFunctionClass(..),
-         mxFunction__0,
-         mxFunction__1,
-         mxFunction__2,
-         mxFunction__3,
-         mxFunction__4,
-         mxFunction__5,
-         mxFunction__6,
-         mxFunction__7,
-         mxFunction__8,
-         mxFunction__9,
-         mxFunction_countNodes,
-         mxFunction_expand__0,
-         mxFunction_expand__1,
-         mxFunction_generateLiftingFunctions,
-         mxFunction_getFree,
-         mxFunction_grad__0,
-         mxFunction_grad__1,
-         mxFunction_grad__2,
-         mxFunction_grad__3,
-         mxFunction_grad__4,
-         mxFunction_grad__5,
-         mxFunction_grad__6,
-         mxFunction_inputExpr__0,
-         mxFunction_inputExpr__1,
-         mxFunction_inputExpr__2,
-         mxFunction_jac__0,
-         mxFunction_jac__1,
-         mxFunction_jac__10,
-         mxFunction_jac__11,
-         mxFunction_jac__12,
-         mxFunction_jac__13,
-         mxFunction_jac__14,
-         mxFunction_jac__2,
-         mxFunction_jac__3,
-         mxFunction_jac__4,
-         mxFunction_jac__5,
-         mxFunction_jac__6,
-         mxFunction_jac__7,
-         mxFunction_jac__8,
-         mxFunction_jac__9,
-         mxFunction_outputExpr__0,
-         mxFunction_outputExpr__1,
-         mxFunction_outputExpr__2,
-         mxFunction_tang__0,
-         mxFunction_tang__1,
-         mxFunction_tang__2,
-         mxFunction_tang__3,
-         mxFunction_tang__4,
-         mxFunction_tang__5,
-         mxFunction_tang__6,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__0" c_casadi__MXFunction__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__0
-  :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__0 :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> IO MXFunction
-mxFunction__0 = casadi__MXFunction__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__1" c_casadi__MXFunction__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__1
-  :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__1 :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction
-mxFunction__1 = casadi__MXFunction__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__2" c_casadi__MXFunction__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__2
-  :: String -> Vector MX -> (M.Map String MX, Vector String) -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__2 :: String -> Vector MX -> (M.Map String MX, Vector String) -> IO MXFunction
-mxFunction__2 = casadi__MXFunction__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__3" c_casadi__MXFunction__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__3
-  :: String -> Vector MX -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__3 :: String -> Vector MX -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction
-mxFunction__3 = casadi__MXFunction__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__4" c_casadi__MXFunction__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__4
-  :: String -> (M.Map String MX, Vector String) -> Vector MX -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__4 :: String -> (M.Map String MX, Vector String) -> Vector MX -> IO MXFunction
-mxFunction__4 = casadi__MXFunction__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__5" c_casadi__MXFunction__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__5
-  :: String -> (M.Map String MX, Vector String) -> Vector MX -> M.Map String GenericType -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__5 :: String -> (M.Map String MX, Vector String) -> Vector MX -> M.Map String GenericType -> IO MXFunction
-mxFunction__5 = casadi__MXFunction__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__6" c_casadi__MXFunction__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__6
-  :: String -> Vector MX -> Vector MX -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__6 :: String -> Vector MX -> Vector MX -> IO MXFunction
-mxFunction__6 = casadi__MXFunction__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__7" c_casadi__MXFunction__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__7
-  :: String -> Vector MX -> Vector MX -> M.Map String GenericType -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__7 :: String -> Vector MX -> Vector MX -> M.Map String GenericType -> IO MXFunction
-mxFunction__7 = casadi__MXFunction__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__8" c_casadi__MXFunction__CONSTRUCTOR__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__8
-  :: Function -> IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__8 :: Function -> IO MXFunction
-mxFunction__8 = casadi__MXFunction__CONSTRUCTOR__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__9" c_casadi__MXFunction__CONSTRUCTOR__9
-  :: Ptr (Ptr StdString) -> IO (Ptr MXFunction')
-casadi__MXFunction__CONSTRUCTOR__9
-  :: IO MXFunction
-casadi__MXFunction__CONSTRUCTOR__9  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__CONSTRUCTOR__9 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction__9 :: IO MXFunction
-mxFunction__9 = casadi__MXFunction__CONSTRUCTOR__9
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__countNodes" c_casadi__MXFunction__countNodes
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO CInt
-casadi__MXFunction__countNodes
-  :: MXFunction -> IO Int
-casadi__MXFunction__countNodes x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__countNodes errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_countNodes :: MXFunctionClass a => a -> IO Int
-mxFunction_countNodes x = casadi__MXFunction__countNodes (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__expand__0" c_casadi__MXFunction__expand__0
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr SXFunction')
-casadi__MXFunction__expand__0
-  :: MXFunction -> IO SXFunction
-casadi__MXFunction__expand__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__expand__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_expand__0 :: MXFunctionClass a => a -> IO SXFunction
-mxFunction_expand__0 x = casadi__MXFunction__expand__0 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__expand__1" c_casadi__MXFunction__expand__1
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SXFunction')
-casadi__MXFunction__expand__1
-  :: MXFunction -> Vector SX -> IO SXFunction
-casadi__MXFunction__expand__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__expand__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_expand__1 :: MXFunctionClass a => a -> Vector SX -> IO SXFunction
-mxFunction_expand__1 x = casadi__MXFunction__expand__1 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__generateLiftingFunctions" c_casadi__MXFunction__generateLiftingFunctions
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr MXFunction' -> Ptr MXFunction' -> IO ()
-casadi__MXFunction__generateLiftingFunctions
-  :: MXFunction -> MXFunction -> MXFunction -> IO ()
-casadi__MXFunction__generateLiftingFunctions x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__generateLiftingFunctions errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_generateLiftingFunctions :: MXFunctionClass a => a -> MXFunction -> MXFunction -> IO ()
-mxFunction_generateLiftingFunctions x = casadi__MXFunction__generateLiftingFunctions (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__getFree" c_casadi__MXFunction__getFree
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr (StdVec (Ptr MX')))
-casadi__MXFunction__getFree
-  :: MXFunction -> IO (Vector MX)
-casadi__MXFunction__getFree x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__getFree errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_getFree :: MXFunctionClass a => a -> IO (Vector MX)
-mxFunction_getFree x = casadi__MXFunction__getFree (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__grad__0" c_casadi__MXFunction__grad__0
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__grad__0
-  :: MXFunction -> String -> String -> IO MX
-casadi__MXFunction__grad__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__grad__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_grad__0 :: MXFunctionClass a => a -> String -> String -> IO MX
-mxFunction_grad__0 x = casadi__MXFunction__grad__0 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__grad__1" c_casadi__MXFunction__grad__1
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__grad__1
-  :: MXFunction -> Int -> String -> IO MX
-casadi__MXFunction__grad__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__grad__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_grad__1 :: MXFunctionClass a => a -> Int -> String -> IO MX
-mxFunction_grad__1 x = casadi__MXFunction__grad__1 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__grad__2" c_casadi__MXFunction__grad__2
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__grad__2
-  :: MXFunction -> String -> IO MX
-casadi__MXFunction__grad__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__grad__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_grad__2 :: MXFunctionClass a => a -> String -> IO MX
-mxFunction_grad__2 x = casadi__MXFunction__grad__2 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__grad__3" c_casadi__MXFunction__grad__3
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__MXFunction__grad__3
-  :: MXFunction -> String -> Int -> IO MX
-casadi__MXFunction__grad__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__grad__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_grad__3 :: MXFunctionClass a => a -> String -> Int -> IO MX
-mxFunction_grad__3 x = casadi__MXFunction__grad__3 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__grad__4" c_casadi__MXFunction__grad__4
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr MX')
-casadi__MXFunction__grad__4
-  :: MXFunction -> IO MX
-casadi__MXFunction__grad__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__grad__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_grad__4 :: MXFunctionClass a => a -> IO MX
-mxFunction_grad__4 x = casadi__MXFunction__grad__4 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__grad__5" c_casadi__MXFunction__grad__5
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> IO (Ptr MX')
-casadi__MXFunction__grad__5
-  :: MXFunction -> Int -> IO MX
-casadi__MXFunction__grad__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__grad__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_grad__5 :: MXFunctionClass a => a -> Int -> IO MX
-mxFunction_grad__5 x = casadi__MXFunction__grad__5 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__grad__6" c_casadi__MXFunction__grad__6
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__grad__6
-  :: MXFunction -> Int -> Int -> IO MX
-casadi__MXFunction__grad__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__grad__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_grad__6 :: MXFunctionClass a => a -> Int -> Int -> IO MX
-mxFunction_grad__6 x = casadi__MXFunction__grad__6 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__inputExpr__0" c_casadi__MXFunction__inputExpr__0
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr (StdVec (Ptr MX')))
-casadi__MXFunction__inputExpr__0
-  :: MXFunction -> IO (Vector MX)
-casadi__MXFunction__inputExpr__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__inputExpr__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_inputExpr__0 :: MXFunctionClass a => a -> IO (Vector MX)
-mxFunction_inputExpr__0 x = casadi__MXFunction__inputExpr__0 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__inputExpr__1" c_casadi__MXFunction__inputExpr__1
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__inputExpr__1
-  :: MXFunction -> String -> IO MX
-casadi__MXFunction__inputExpr__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__inputExpr__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_inputExpr__1 :: MXFunctionClass a => a -> String -> IO MX
-mxFunction_inputExpr__1 x = casadi__MXFunction__inputExpr__1 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__inputExpr__2" c_casadi__MXFunction__inputExpr__2
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> IO (Ptr MX')
-casadi__MXFunction__inputExpr__2
-  :: MXFunction -> Int -> IO MX
-casadi__MXFunction__inputExpr__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__inputExpr__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_inputExpr__2 :: MXFunctionClass a => a -> Int -> IO MX
-mxFunction_inputExpr__2 x = casadi__MXFunction__inputExpr__2 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__0" c_casadi__MXFunction__jac__0
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__jac__0
-  :: MXFunction -> String -> String -> IO MX
-casadi__MXFunction__jac__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__0 :: MXFunctionClass a => a -> String -> String -> IO MX
-mxFunction_jac__0 x = casadi__MXFunction__jac__0 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__1" c_casadi__MXFunction__jac__1
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__1
-  :: MXFunction -> String -> String -> Bool -> IO MX
-casadi__MXFunction__jac__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__1 :: MXFunctionClass a => a -> String -> String -> Bool -> IO MX
-mxFunction_jac__1 x = casadi__MXFunction__jac__1 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__2" c_casadi__MXFunction__jac__2
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__2
-  :: MXFunction -> String -> String -> Bool -> Bool -> IO MX
-casadi__MXFunction__jac__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__2 :: MXFunctionClass a => a -> String -> String -> Bool -> Bool -> IO MX
-mxFunction_jac__2 x = casadi__MXFunction__jac__2 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__3" c_casadi__MXFunction__jac__3
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__jac__3
-  :: MXFunction -> Int -> String -> IO MX
-casadi__MXFunction__jac__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__3 :: MXFunctionClass a => a -> Int -> String -> IO MX
-mxFunction_jac__3 x = casadi__MXFunction__jac__3 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__4" c_casadi__MXFunction__jac__4
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__4
-  :: MXFunction -> Int -> String -> Bool -> IO MX
-casadi__MXFunction__jac__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__4 :: MXFunctionClass a => a -> Int -> String -> Bool -> IO MX
-mxFunction_jac__4 x = casadi__MXFunction__jac__4 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__5" c_casadi__MXFunction__jac__5
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__5
-  :: MXFunction -> Int -> String -> Bool -> Bool -> IO MX
-casadi__MXFunction__jac__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__5 :: MXFunctionClass a => a -> Int -> String -> Bool -> Bool -> IO MX
-mxFunction_jac__5 x = casadi__MXFunction__jac__5 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__6" c_casadi__MXFunction__jac__6
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__jac__6
-  :: MXFunction -> String -> IO MX
-casadi__MXFunction__jac__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__6 :: MXFunctionClass a => a -> String -> IO MX
-mxFunction_jac__6 x = casadi__MXFunction__jac__6 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__7" c_casadi__MXFunction__jac__7
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__7
-  :: MXFunction -> String -> Int -> IO MX
-casadi__MXFunction__jac__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__7 :: MXFunctionClass a => a -> String -> Int -> IO MX
-mxFunction_jac__7 x = casadi__MXFunction__jac__7 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__8" c_casadi__MXFunction__jac__8
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__8
-  :: MXFunction -> String -> Int -> Bool -> IO MX
-casadi__MXFunction__jac__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__8 :: MXFunctionClass a => a -> String -> Int -> Bool -> IO MX
-mxFunction_jac__8 x = casadi__MXFunction__jac__8 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__9" c_casadi__MXFunction__jac__9
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__9
-  :: MXFunction -> String -> Int -> Bool -> Bool -> IO MX
-casadi__MXFunction__jac__9 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__9 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__9 :: MXFunctionClass a => a -> String -> Int -> Bool -> Bool -> IO MX
-mxFunction_jac__9 x = casadi__MXFunction__jac__9 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__10" c_casadi__MXFunction__jac__10
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr MX')
-casadi__MXFunction__jac__10
-  :: MXFunction -> IO MX
-casadi__MXFunction__jac__10 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__10 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__10 :: MXFunctionClass a => a -> IO MX
-mxFunction_jac__10 x = casadi__MXFunction__jac__10 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__11" c_casadi__MXFunction__jac__11
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__11
-  :: MXFunction -> Int -> IO MX
-casadi__MXFunction__jac__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__11 :: MXFunctionClass a => a -> Int -> IO MX
-mxFunction_jac__11 x = casadi__MXFunction__jac__11 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__12" c_casadi__MXFunction__jac__12
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__12
-  :: MXFunction -> Int -> Int -> IO MX
-casadi__MXFunction__jac__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__12 :: MXFunctionClass a => a -> Int -> Int -> IO MX
-mxFunction_jac__12 x = casadi__MXFunction__jac__12 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__13" c_casadi__MXFunction__jac__13
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__13
-  :: MXFunction -> Int -> Int -> Bool -> IO MX
-casadi__MXFunction__jac__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__13 :: MXFunctionClass a => a -> Int -> Int -> Bool -> IO MX
-mxFunction_jac__13 x = casadi__MXFunction__jac__13 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__jac__14" c_casadi__MXFunction__jac__14
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__jac__14
-  :: MXFunction -> Int -> Int -> Bool -> Bool -> IO MX
-casadi__MXFunction__jac__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__jac__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_jac__14 :: MXFunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO MX
-mxFunction_jac__14 x = casadi__MXFunction__jac__14 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__outputExpr__0" c_casadi__MXFunction__outputExpr__0
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr (StdVec (Ptr MX')))
-casadi__MXFunction__outputExpr__0
-  :: MXFunction -> IO (Vector MX)
-casadi__MXFunction__outputExpr__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__outputExpr__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_outputExpr__0 :: MXFunctionClass a => a -> IO (Vector MX)
-mxFunction_outputExpr__0 x = casadi__MXFunction__outputExpr__0 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__outputExpr__1" c_casadi__MXFunction__outputExpr__1
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__outputExpr__1
-  :: MXFunction -> String -> IO MX
-casadi__MXFunction__outputExpr__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__outputExpr__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_outputExpr__1 :: MXFunctionClass a => a -> String -> IO MX
-mxFunction_outputExpr__1 x = casadi__MXFunction__outputExpr__1 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__outputExpr__2" c_casadi__MXFunction__outputExpr__2
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> IO (Ptr MX')
-casadi__MXFunction__outputExpr__2
-  :: MXFunction -> Int -> IO MX
-casadi__MXFunction__outputExpr__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__outputExpr__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_outputExpr__2 :: MXFunctionClass a => a -> Int -> IO MX
-mxFunction_outputExpr__2 x = casadi__MXFunction__outputExpr__2 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__tang__0" c_casadi__MXFunction__tang__0
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__tang__0
-  :: MXFunction -> String -> String -> IO MX
-casadi__MXFunction__tang__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__tang__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_tang__0 :: MXFunctionClass a => a -> String -> String -> IO MX
-mxFunction_tang__0 x = casadi__MXFunction__tang__0 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__tang__1" c_casadi__MXFunction__tang__1
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__tang__1
-  :: MXFunction -> Int -> String -> IO MX
-casadi__MXFunction__tang__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__tang__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_tang__1 :: MXFunctionClass a => a -> Int -> String -> IO MX
-mxFunction_tang__1 x = casadi__MXFunction__tang__1 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__tang__2" c_casadi__MXFunction__tang__2
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> IO (Ptr MX')
-casadi__MXFunction__tang__2
-  :: MXFunction -> String -> IO MX
-casadi__MXFunction__tang__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__tang__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_tang__2 :: MXFunctionClass a => a -> String -> IO MX
-mxFunction_tang__2 x = casadi__MXFunction__tang__2 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__tang__3" c_casadi__MXFunction__tang__3
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> Ptr StdString -> CInt -> IO (Ptr MX')
-casadi__MXFunction__tang__3
-  :: MXFunction -> String -> Int -> IO MX
-casadi__MXFunction__tang__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__tang__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_tang__3 :: MXFunctionClass a => a -> String -> Int -> IO MX
-mxFunction_tang__3 x = casadi__MXFunction__tang__3 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__tang__4" c_casadi__MXFunction__tang__4
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr MX')
-casadi__MXFunction__tang__4
-  :: MXFunction -> IO MX
-casadi__MXFunction__tang__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__tang__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_tang__4 :: MXFunctionClass a => a -> IO MX
-mxFunction_tang__4 x = casadi__MXFunction__tang__4 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__tang__5" c_casadi__MXFunction__tang__5
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> IO (Ptr MX')
-casadi__MXFunction__tang__5
-  :: MXFunction -> Int -> IO MX
-casadi__MXFunction__tang__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__tang__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_tang__5 :: MXFunctionClass a => a -> Int -> IO MX
-mxFunction_tang__5 x = casadi__MXFunction__tang__5 (castMXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MXFunction__tang__6" c_casadi__MXFunction__tang__6
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> CInt -> CInt -> IO (Ptr MX')
-casadi__MXFunction__tang__6
-  :: MXFunction -> Int -> Int -> IO MX
-casadi__MXFunction__tang__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MXFunction__tang__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mxFunction_tang__6 :: MXFunctionClass a => a -> Int -> Int -> IO MX
-mxFunction_tang__6 x = casadi__MXFunction__tang__6 (castMXFunction x)
-
diff --git a/Casadi/Core/Classes/Map.hs b/Casadi/Core/Classes/Map.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/Map.hs
+++ /dev/null
@@ -1,102 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.Map
-       (
-         Map,
-         MapClass(..),
-         map__0,
-         map__1,
-         map__2,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Map__CONSTRUCTOR__0" c_casadi__Map__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Map')
-casadi__Map__CONSTRUCTOR__0
-  :: String -> Function -> Int -> Vector Bool -> Vector Bool -> IO Map
-casadi__Map__CONSTRUCTOR__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Map__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-map__0 :: String -> Function -> Int -> Vector Bool -> Vector Bool -> IO Map
-map__0 = casadi__Map__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Map__CONSTRUCTOR__1" c_casadi__Map__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Map')
-casadi__Map__CONSTRUCTOR__1
-  :: String -> Function -> Int -> Vector Bool -> Vector Bool -> M.Map String GenericType -> IO Map
-casadi__Map__CONSTRUCTOR__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Map__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-map__1 :: String -> Function -> Int -> Vector Bool -> Vector Bool -> M.Map String GenericType -> IO Map
-map__1 = casadi__Map__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Map__CONSTRUCTOR__2" c_casadi__Map__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr Map')
-casadi__Map__CONSTRUCTOR__2
-  :: IO Map
-casadi__Map__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Map__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-map__2 :: IO Map
-map__2 = casadi__Map__CONSTRUCTOR__2
-
diff --git a/Casadi/Core/Classes/MapAccum.hs b/Casadi/Core/Classes/MapAccum.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/MapAccum.hs
+++ /dev/null
@@ -1,129 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.MapAccum
-       (
-         MapAccum,
-         MapAccumClass(..),
-         mapAccum__0,
-         mapAccum__1,
-         mapAccum__2,
-         mapAccum__3,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__0" c_casadi__MapAccum__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr MapAccum')
-casadi__MapAccum__CONSTRUCTOR__0
-  :: String -> Function -> Int -> Vector Bool -> Vector Int -> IO MapAccum
-casadi__MapAccum__CONSTRUCTOR__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MapAccum__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mapAccum__0 :: String -> Function -> Int -> Vector Bool -> Vector Int -> IO MapAccum
-mapAccum__0 = casadi__MapAccum__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__1" c_casadi__MapAccum__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr MapAccum')
-casadi__MapAccum__CONSTRUCTOR__1
-  :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> IO MapAccum
-casadi__MapAccum__CONSTRUCTOR__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MapAccum__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mapAccum__1 :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> IO MapAccum
-mapAccum__1 = casadi__MapAccum__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__2" c_casadi__MapAccum__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MapAccum')
-casadi__MapAccum__CONSTRUCTOR__2
-  :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> M.Map String GenericType -> IO MapAccum
-casadi__MapAccum__CONSTRUCTOR__2 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MapAccum__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mapAccum__2 :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> M.Map String GenericType -> IO MapAccum
-mapAccum__2 = casadi__MapAccum__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__3" c_casadi__MapAccum__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> IO (Ptr MapAccum')
-casadi__MapAccum__CONSTRUCTOR__3
-  :: IO MapAccum
-casadi__MapAccum__CONSTRUCTOR__3  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__MapAccum__CONSTRUCTOR__3 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-mapAccum__3 :: IO MapAccum
-mapAccum__3 = casadi__MapAccum__CONSTRUCTOR__3
-
diff --git a/Casadi/Core/Classes/MatrixCommon.hs b/Casadi/Core/Classes/MatrixCommon.hs
--- a/Casadi/Core/Classes/MatrixCommon.hs
+++ b/Casadi/Core/Classes/MatrixCommon.hs
@@ -25,7 +25,7 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
diff --git a/Casadi/Core/Classes/NlpBuilder.hs b/Casadi/Core/Classes/NlpBuilder.hs
--- a/Casadi/Core/Classes/NlpBuilder.hs
+++ b/Casadi/Core/Classes/NlpBuilder.hs
@@ -11,8 +11,8 @@
          NlpBuilderClass(..),
          nlpBuilder_getDescription,
          nlpBuilder_getRepresentation,
-         nlpBuilder_parseNL__0,
-         nlpBuilder_parseNL__1,
+         nlpBuilder_parse_nl__0,
+         nlpBuilder_parse_nl__1,
        ) where
 
 
@@ -29,68 +29,92 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
-foreign import ccall unsafe "casadi__NlpBuilder__parseNL__0" c_casadi__NlpBuilder__parseNL__0
+foreign import ccall unsafe "casadi__NlpBuilder__parse_nl__0" c_casadi__NlpBuilder__parse_nl__0
   :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> Ptr StdString -> IO ()
-casadi__NlpBuilder__parseNL__0
+
+casadi__NlpBuilder__parse_nl__0
   :: NlpBuilder -> String -> IO ()
-casadi__NlpBuilder__parseNL__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpBuilder__parseNL__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__NlpBuilder__parse_nl__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__NlpBuilder__parse_nl__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
 -- classy wrapper
-nlpBuilder_parseNL__0 :: NlpBuilderClass a => a -> String -> IO ()
-nlpBuilder_parseNL__0 x = casadi__NlpBuilder__parseNL__0 (castNlpBuilder x)
+nlpBuilder_parse_nl__0 :: NlpBuilderClass a => a -> String -> IO ()
+nlpBuilder_parse_nl__0 x = casadi__NlpBuilder__parse_nl__0 (castNlpBuilder x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__NlpBuilder__parseNL__1" c_casadi__NlpBuilder__parseNL__1
+foreign import ccall unsafe "casadi__NlpBuilder__parse_nl__1" c_casadi__NlpBuilder__parse_nl__1
   :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
-casadi__NlpBuilder__parseNL__1
+
+casadi__NlpBuilder__parse_nl__1
   :: NlpBuilder -> String -> M.Map String GenericType -> IO ()
-casadi__NlpBuilder__parseNL__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpBuilder__parseNL__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__NlpBuilder__parse_nl__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__NlpBuilder__parse_nl__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
 -- classy wrapper
-nlpBuilder_parseNL__1 :: NlpBuilderClass a => a -> String -> M.Map String GenericType -> IO ()
-nlpBuilder_parseNL__1 x = casadi__NlpBuilder__parseNL__1 (castNlpBuilder x)
+nlpBuilder_parse_nl__1 :: NlpBuilderClass a => a -> String -> M.Map String GenericType -> IO ()
+nlpBuilder_parse_nl__1 x = casadi__NlpBuilder__parse_nl__1 (castNlpBuilder x)
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__NlpBuilder__getRepresentation" c_casadi__NlpBuilder__getRepresentation
   :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> IO (Ptr StdString)
+
 casadi__NlpBuilder__getRepresentation
   :: NlpBuilder -> IO String
-casadi__NlpBuilder__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpBuilder__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__NlpBuilder__getRepresentation x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__NlpBuilder__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 nlpBuilder_getRepresentation :: NlpBuilderClass a => a -> IO String
 nlpBuilder_getRepresentation x = casadi__NlpBuilder__getRepresentation (castNlpBuilder x)
@@ -99,16 +123,23 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__NlpBuilder__getDescription" c_casadi__NlpBuilder__getDescription
   :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> IO (Ptr StdString)
+
 casadi__NlpBuilder__getDescription
   :: NlpBuilder -> IO String
-casadi__NlpBuilder__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpBuilder__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__NlpBuilder__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__NlpBuilder__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/NlpSolver.hs b/Casadi/Core/Classes/NlpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/NlpSolver.hs
+++ /dev/null
@@ -1,424 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.NlpSolver
-       (
-         NlpSolver,
-         NlpSolverClass(..),
-         nlpSolver__0,
-         nlpSolver__1,
-         nlpSolver__2,
-         nlpSolver__3,
-         nlpSolver__4,
-         nlpSolver__5,
-         nlpSolver__6,
-         nlpSolver_doc,
-         nlpSolver_getReducedHessian,
-         nlpSolver_getReportConstraints,
-         nlpSolver_gradF,
-         nlpSolver_hasPlugin,
-         nlpSolver_hessLag,
-         nlpSolver_jacG,
-         nlpSolver_loadPlugin,
-         nlpSolver_nlp,
-         nlpSolver_reportConstraints,
-         nlpSolver_setOptionsFromFile,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__0" c_casadi__NlpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr NlpSolver')
-casadi__NlpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String MX -> IO NlpSolver
-casadi__NlpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver__0 :: String -> String -> M.Map String MX -> IO NlpSolver
-nlpSolver__0 = casadi__NlpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__1" c_casadi__NlpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr NlpSolver')
-casadi__NlpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO NlpSolver
-casadi__NlpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver__1 :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO NlpSolver
-nlpSolver__1 = casadi__NlpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__2" c_casadi__NlpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr NlpSolver')
-casadi__NlpSolver__CONSTRUCTOR__2
-  :: String -> String -> M.Map String SX -> IO NlpSolver
-casadi__NlpSolver__CONSTRUCTOR__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__CONSTRUCTOR__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver__2 :: String -> String -> M.Map String SX -> IO NlpSolver
-nlpSolver__2 = casadi__NlpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__3" c_casadi__NlpSolver__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr NlpSolver')
-casadi__NlpSolver__CONSTRUCTOR__3
-  :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO NlpSolver
-casadi__NlpSolver__CONSTRUCTOR__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver__3 :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO NlpSolver
-nlpSolver__3 = casadi__NlpSolver__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__4" c_casadi__NlpSolver__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr NlpSolver')
-casadi__NlpSolver__CONSTRUCTOR__4
-  :: String -> String -> Function -> IO NlpSolver
-casadi__NlpSolver__CONSTRUCTOR__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__CONSTRUCTOR__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver__4 :: String -> String -> Function -> IO NlpSolver
-nlpSolver__4 = casadi__NlpSolver__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__5" c_casadi__NlpSolver__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr NlpSolver')
-casadi__NlpSolver__CONSTRUCTOR__5
-  :: String -> String -> Function -> M.Map String GenericType -> IO NlpSolver
-casadi__NlpSolver__CONSTRUCTOR__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver__5 :: String -> String -> Function -> M.Map String GenericType -> IO NlpSolver
-nlpSolver__5 = casadi__NlpSolver__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__6" c_casadi__NlpSolver__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> IO (Ptr NlpSolver')
-casadi__NlpSolver__CONSTRUCTOR__6
-  :: IO NlpSolver
-casadi__NlpSolver__CONSTRUCTOR__6  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__CONSTRUCTOR__6 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver__6 :: IO NlpSolver
-nlpSolver__6 = casadi__NlpSolver__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__doc" c_casadi__NlpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__NlpSolver__doc
-  :: String -> IO String
-casadi__NlpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_doc :: String -> IO String
-nlpSolver_doc = casadi__NlpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__getReducedHessian" c_casadi__NlpSolver__getReducedHessian
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO (Ptr DMatrix')
-casadi__NlpSolver__getReducedHessian
-  :: NlpSolver -> IO DMatrix
-casadi__NlpSolver__getReducedHessian x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__getReducedHessian errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_getReducedHessian :: NlpSolverClass a => a -> IO DMatrix
-nlpSolver_getReducedHessian x = casadi__NlpSolver__getReducedHessian (castNlpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__getReportConstraints" c_casadi__NlpSolver__getReportConstraints
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO (Ptr StdString)
-casadi__NlpSolver__getReportConstraints
-  :: NlpSolver -> IO String
-casadi__NlpSolver__getReportConstraints x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__getReportConstraints errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_getReportConstraints :: NlpSolverClass a => a -> IO String
-nlpSolver_getReportConstraints x = casadi__NlpSolver__getReportConstraints (castNlpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__gradF" c_casadi__NlpSolver__gradF
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO (Ptr Function')
-casadi__NlpSolver__gradF
-  :: NlpSolver -> IO Function
-casadi__NlpSolver__gradF x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__gradF errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_gradF :: NlpSolverClass a => a -> IO Function
-nlpSolver_gradF x = casadi__NlpSolver__gradF (castNlpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__hasPlugin" c_casadi__NlpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__NlpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__NlpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_hasPlugin :: String -> IO Bool
-nlpSolver_hasPlugin = casadi__NlpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__hessLag" c_casadi__NlpSolver__hessLag
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO (Ptr Function')
-casadi__NlpSolver__hessLag
-  :: NlpSolver -> IO Function
-casadi__NlpSolver__hessLag x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__hessLag errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_hessLag :: NlpSolverClass a => a -> IO Function
-nlpSolver_hessLag x = casadi__NlpSolver__hessLag (castNlpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__jacG" c_casadi__NlpSolver__jacG
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO (Ptr Function')
-casadi__NlpSolver__jacG
-  :: NlpSolver -> IO Function
-casadi__NlpSolver__jacG x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__jacG errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_jacG :: NlpSolverClass a => a -> IO Function
-nlpSolver_jacG x = casadi__NlpSolver__jacG (castNlpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__loadPlugin" c_casadi__NlpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__NlpSolver__loadPlugin
-  :: String -> IO ()
-casadi__NlpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_loadPlugin :: String -> IO ()
-nlpSolver_loadPlugin = casadi__NlpSolver__loadPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__nlp" c_casadi__NlpSolver__nlp
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO (Ptr Function')
-casadi__NlpSolver__nlp
-  :: NlpSolver -> IO Function
-casadi__NlpSolver__nlp x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__nlp errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_nlp :: NlpSolverClass a => a -> IO Function
-nlpSolver_nlp x = casadi__NlpSolver__nlp (castNlpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__reportConstraints" c_casadi__NlpSolver__reportConstraints
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO ()
-casadi__NlpSolver__reportConstraints
-  :: NlpSolver -> IO ()
-casadi__NlpSolver__reportConstraints x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__reportConstraints errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_reportConstraints :: NlpSolverClass a => a -> IO ()
-nlpSolver_reportConstraints x = casadi__NlpSolver__reportConstraints (castNlpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__NlpSolver__setOptionsFromFile" c_casadi__NlpSolver__setOptionsFromFile
-  :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> Ptr StdString -> IO ()
-casadi__NlpSolver__setOptionsFromFile
-  :: NlpSolver -> String -> IO ()
-casadi__NlpSolver__setOptionsFromFile x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__NlpSolver__setOptionsFromFile errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nlpSolver_setOptionsFromFile :: NlpSolverClass a => a -> String -> IO ()
-nlpSolver_setOptionsFromFile x = casadi__NlpSolver__setOptionsFromFile (castNlpSolver x)
-
diff --git a/Casadi/Core/Classes/Nullspace.hs b/Casadi/Core/Classes/Nullspace.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/Nullspace.hs
+++ /dev/null
@@ -1,51 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.Nullspace
-       (
-         Nullspace,
-         NullspaceClass(..),
-         nullspace,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Nullspace__CONSTRUCTOR" c_casadi__Nullspace__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr Nullspace')
-casadi__Nullspace__CONSTRUCTOR
-  :: IO Nullspace
-casadi__Nullspace__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Nullspace__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-nullspace :: IO Nullspace
-nullspace = casadi__Nullspace__CONSTRUCTOR
-
diff --git a/Casadi/Core/Classes/OptionsFunctionality.hs b/Casadi/Core/Classes/OptionsFunctionality.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/OptionsFunctionality.hs
+++ /dev/null
@@ -1,515 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.OptionsFunctionality
-       (
-         OptionsFunctionality,
-         OptionsFunctionalityClass(..),
-         optionsFunctionality,
-         optionsFunctionality_addOptionRecipe,
-         optionsFunctionality_copyOptions__0,
-         optionsFunctionality_copyOptions__1,
-         optionsFunctionality_dictionary,
-         optionsFunctionality_getOption,
-         optionsFunctionality_getOptionAllowed,
-         optionsFunctionality_getOptionAllowedIndex,
-         optionsFunctionality_getOptionDefault,
-         optionsFunctionality_getOptionDescription,
-         optionsFunctionality_getOptionEnumValue,
-         optionsFunctionality_getOptionNames,
-         optionsFunctionality_getOptionType,
-         optionsFunctionality_getOptionTypeName,
-         optionsFunctionality_hasOption,
-         optionsFunctionality_hasSetOption,
-         optionsFunctionality_printOptions,
-         optionsFunctionality_setOptionByAllowedIndex,
-         optionsFunctionality_setOptionByEnumValue,
-         optionsFunctionality_setOption__0,
-         optionsFunctionality_setOption__1,
-         optionsFunctionality_setOption__2,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__CONSTRUCTOR" c_casadi__OptionsFunctionality__CONSTRUCTOR
-  :: Ptr (Ptr StdString) -> IO (Ptr OptionsFunctionality')
-casadi__OptionsFunctionality__CONSTRUCTOR
-  :: IO OptionsFunctionality
-casadi__OptionsFunctionality__CONSTRUCTOR  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__CONSTRUCTOR errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality :: IO OptionsFunctionality
-optionsFunctionality = casadi__OptionsFunctionality__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__addOptionRecipe" c_casadi__OptionsFunctionality__addOptionRecipe
-  :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr GenericType')) -> Ptr StdString -> IO (Ptr (StdMap StdString (Ptr GenericType')))
-casadi__OptionsFunctionality__addOptionRecipe
-  :: M.Map String GenericType -> String -> IO (M.Map String GenericType)
-casadi__OptionsFunctionality__addOptionRecipe x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__addOptionRecipe errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_addOptionRecipe :: M.Map String GenericType -> String -> IO (M.Map String GenericType)
-optionsFunctionality_addOptionRecipe = casadi__OptionsFunctionality__addOptionRecipe
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__copyOptions__0" c_casadi__OptionsFunctionality__copyOptions__0
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr OptionsFunctionality' -> IO ()
-casadi__OptionsFunctionality__copyOptions__0
-  :: OptionsFunctionality -> OptionsFunctionality -> IO ()
-casadi__OptionsFunctionality__copyOptions__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__copyOptions__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_copyOptions__0 :: OptionsFunctionalityClass a => a -> OptionsFunctionality -> IO ()
-optionsFunctionality_copyOptions__0 x = casadi__OptionsFunctionality__copyOptions__0 (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__copyOptions__1" c_casadi__OptionsFunctionality__copyOptions__1
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr OptionsFunctionality' -> CInt -> IO ()
-casadi__OptionsFunctionality__copyOptions__1
-  :: OptionsFunctionality -> OptionsFunctionality -> Bool -> IO ()
-casadi__OptionsFunctionality__copyOptions__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__copyOptions__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_copyOptions__1 :: OptionsFunctionalityClass a => a -> OptionsFunctionality -> Bool -> IO ()
-optionsFunctionality_copyOptions__1 x = casadi__OptionsFunctionality__copyOptions__1 (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__dictionary" c_casadi__OptionsFunctionality__dictionary
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> IO (Ptr (StdMap StdString (Ptr GenericType')))
-casadi__OptionsFunctionality__dictionary
-  :: OptionsFunctionality -> IO (M.Map String GenericType)
-casadi__OptionsFunctionality__dictionary x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__dictionary errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_dictionary :: OptionsFunctionalityClass a => a -> IO (M.Map String GenericType)
-optionsFunctionality_dictionary x = casadi__OptionsFunctionality__dictionary (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOption" c_casadi__OptionsFunctionality__getOption
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO (Ptr GenericType')
-casadi__OptionsFunctionality__getOption
-  :: OptionsFunctionality -> String -> IO GenericType
-casadi__OptionsFunctionality__getOption x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOption errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOption :: OptionsFunctionalityClass a => a -> String -> IO GenericType
-optionsFunctionality_getOption x = casadi__OptionsFunctionality__getOption (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionAllowed" c_casadi__OptionsFunctionality__getOptionAllowed
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO (Ptr (StdVec (Ptr GenericType')))
-casadi__OptionsFunctionality__getOptionAllowed
-  :: OptionsFunctionality -> String -> IO (Vector GenericType)
-casadi__OptionsFunctionality__getOptionAllowed x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionAllowed errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionAllowed :: OptionsFunctionalityClass a => a -> String -> IO (Vector GenericType)
-optionsFunctionality_getOptionAllowed x = casadi__OptionsFunctionality__getOptionAllowed (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionAllowedIndex" c_casadi__OptionsFunctionality__getOptionAllowedIndex
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO CInt
-casadi__OptionsFunctionality__getOptionAllowedIndex
-  :: OptionsFunctionality -> String -> IO Int
-casadi__OptionsFunctionality__getOptionAllowedIndex x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionAllowedIndex errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionAllowedIndex :: OptionsFunctionalityClass a => a -> String -> IO Int
-optionsFunctionality_getOptionAllowedIndex x = casadi__OptionsFunctionality__getOptionAllowedIndex (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionDefault" c_casadi__OptionsFunctionality__getOptionDefault
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO (Ptr GenericType')
-casadi__OptionsFunctionality__getOptionDefault
-  :: OptionsFunctionality -> String -> IO GenericType
-casadi__OptionsFunctionality__getOptionDefault x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionDefault errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionDefault :: OptionsFunctionalityClass a => a -> String -> IO GenericType
-optionsFunctionality_getOptionDefault x = casadi__OptionsFunctionality__getOptionDefault (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionDescription" c_casadi__OptionsFunctionality__getOptionDescription
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO (Ptr StdString)
-casadi__OptionsFunctionality__getOptionDescription
-  :: OptionsFunctionality -> String -> IO String
-casadi__OptionsFunctionality__getOptionDescription x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionDescription errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionDescription :: OptionsFunctionalityClass a => a -> String -> IO String
-optionsFunctionality_getOptionDescription x = casadi__OptionsFunctionality__getOptionDescription (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionEnumValue" c_casadi__OptionsFunctionality__getOptionEnumValue
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO CInt
-casadi__OptionsFunctionality__getOptionEnumValue
-  :: OptionsFunctionality -> String -> IO Int
-casadi__OptionsFunctionality__getOptionEnumValue x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionEnumValue errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionEnumValue :: OptionsFunctionalityClass a => a -> String -> IO Int
-optionsFunctionality_getOptionEnumValue x = casadi__OptionsFunctionality__getOptionEnumValue (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionNames" c_casadi__OptionsFunctionality__getOptionNames
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> IO (Ptr (StdVec (Ptr StdString)))
-casadi__OptionsFunctionality__getOptionNames
-  :: OptionsFunctionality -> IO (Vector String)
-casadi__OptionsFunctionality__getOptionNames x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionNames errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionNames :: OptionsFunctionalityClass a => a -> IO (Vector String)
-optionsFunctionality_getOptionNames x = casadi__OptionsFunctionality__getOptionNames (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionType" c_casadi__OptionsFunctionality__getOptionType
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO CInt
-casadi__OptionsFunctionality__getOptionType
-  :: OptionsFunctionality -> String -> IO TypeID
-casadi__OptionsFunctionality__getOptionType x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionType errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionType :: OptionsFunctionalityClass a => a -> String -> IO TypeID
-optionsFunctionality_getOptionType x = casadi__OptionsFunctionality__getOptionType (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionTypeName" c_casadi__OptionsFunctionality__getOptionTypeName
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO (Ptr StdString)
-casadi__OptionsFunctionality__getOptionTypeName
-  :: OptionsFunctionality -> String -> IO String
-casadi__OptionsFunctionality__getOptionTypeName x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__getOptionTypeName errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_getOptionTypeName :: OptionsFunctionalityClass a => a -> String -> IO String
-optionsFunctionality_getOptionTypeName x = casadi__OptionsFunctionality__getOptionTypeName (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__hasOption" c_casadi__OptionsFunctionality__hasOption
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO CInt
-casadi__OptionsFunctionality__hasOption
-  :: OptionsFunctionality -> String -> IO Bool
-casadi__OptionsFunctionality__hasOption x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__hasOption errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_hasOption :: OptionsFunctionalityClass a => a -> String -> IO Bool
-optionsFunctionality_hasOption x = casadi__OptionsFunctionality__hasOption (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__hasSetOption" c_casadi__OptionsFunctionality__hasSetOption
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO CInt
-casadi__OptionsFunctionality__hasSetOption
-  :: OptionsFunctionality -> String -> IO Bool
-casadi__OptionsFunctionality__hasSetOption x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__hasSetOption errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_hasSetOption :: OptionsFunctionalityClass a => a -> String -> IO Bool
-optionsFunctionality_hasSetOption x = casadi__OptionsFunctionality__hasSetOption (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__printOptions" c_casadi__OptionsFunctionality__printOptions
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> IO ()
-casadi__OptionsFunctionality__printOptions
-  :: OptionsFunctionality -> IO ()
-casadi__OptionsFunctionality__printOptions x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__printOptions errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_printOptions :: OptionsFunctionalityClass a => a -> IO ()
-optionsFunctionality_printOptions x = casadi__OptionsFunctionality__printOptions (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__setOption__0" c_casadi__OptionsFunctionality__setOption__0
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO ()
-casadi__OptionsFunctionality__setOption__0
-  :: OptionsFunctionality -> M.Map String GenericType -> IO ()
-casadi__OptionsFunctionality__setOption__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__setOption__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_setOption__0 :: OptionsFunctionalityClass a => a -> M.Map String GenericType -> IO ()
-optionsFunctionality_setOption__0 x = casadi__OptionsFunctionality__setOption__0 (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__setOption__1" c_casadi__OptionsFunctionality__setOption__1
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr (StdMap StdString (Ptr GenericType')) -> CInt -> IO ()
-casadi__OptionsFunctionality__setOption__1
-  :: OptionsFunctionality -> M.Map String GenericType -> Bool -> IO ()
-casadi__OptionsFunctionality__setOption__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__setOption__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_setOption__1 :: OptionsFunctionalityClass a => a -> M.Map String GenericType -> Bool -> IO ()
-optionsFunctionality_setOption__1 x = casadi__OptionsFunctionality__setOption__1 (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__setOption__2" c_casadi__OptionsFunctionality__setOption__2
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> Ptr GenericType' -> IO ()
-casadi__OptionsFunctionality__setOption__2
-  :: OptionsFunctionality -> String -> GenericType -> IO ()
-casadi__OptionsFunctionality__setOption__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__setOption__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_setOption__2 :: OptionsFunctionalityClass a => a -> String -> GenericType -> IO ()
-optionsFunctionality_setOption__2 x = casadi__OptionsFunctionality__setOption__2 (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__setOptionByAllowedIndex" c_casadi__OptionsFunctionality__setOptionByAllowedIndex
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> CInt -> IO ()
-casadi__OptionsFunctionality__setOptionByAllowedIndex
-  :: OptionsFunctionality -> String -> Int -> IO ()
-casadi__OptionsFunctionality__setOptionByAllowedIndex x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__setOptionByAllowedIndex errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_setOptionByAllowedIndex :: OptionsFunctionalityClass a => a -> String -> Int -> IO ()
-optionsFunctionality_setOptionByAllowedIndex x = casadi__OptionsFunctionality__setOptionByAllowedIndex (castOptionsFunctionality x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OptionsFunctionality__setOptionByEnumValue" c_casadi__OptionsFunctionality__setOptionByEnumValue
-  :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> CInt -> IO ()
-casadi__OptionsFunctionality__setOptionByEnumValue
-  :: OptionsFunctionality -> String -> Int -> IO ()
-casadi__OptionsFunctionality__setOptionByEnumValue x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__OptionsFunctionality__setOptionByEnumValue errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-optionsFunctionality_setOptionByEnumValue :: OptionsFunctionalityClass a => a -> String -> Int -> IO ()
-optionsFunctionality_setOptionByEnumValue x = casadi__OptionsFunctionality__setOptionByEnumValue (castOptionsFunctionality x)
-
diff --git a/Casadi/Core/Classes/QcqpSolver.hs b/Casadi/Core/Classes/QcqpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/QcqpSolver.hs
+++ /dev/null
@@ -1,161 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.QcqpSolver
-       (
-         QcqpSolver,
-         QcqpSolverClass(..),
-         qcqpSolver__0,
-         qcqpSolver__1,
-         qcqpSolver__2,
-         qcqpSolver_doc,
-         qcqpSolver_hasPlugin,
-         qcqpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR__0" c_casadi__QcqpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr QcqpSolver')
-casadi__QcqpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO QcqpSolver
-casadi__QcqpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QcqpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qcqpSolver__0 :: String -> String -> M.Map String Sparsity -> IO QcqpSolver
-qcqpSolver__0 = casadi__QcqpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR__1" c_casadi__QcqpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr QcqpSolver')
-casadi__QcqpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QcqpSolver
-casadi__QcqpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QcqpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qcqpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QcqpSolver
-qcqpSolver__1 = casadi__QcqpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR__2" c_casadi__QcqpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr QcqpSolver')
-casadi__QcqpSolver__CONSTRUCTOR__2
-  :: IO QcqpSolver
-casadi__QcqpSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QcqpSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qcqpSolver__2 :: IO QcqpSolver
-qcqpSolver__2 = casadi__QcqpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QcqpSolver__doc" c_casadi__QcqpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__QcqpSolver__doc
-  :: String -> IO String
-casadi__QcqpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QcqpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qcqpSolver_doc :: String -> IO String
-qcqpSolver_doc = casadi__QcqpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QcqpSolver__hasPlugin" c_casadi__QcqpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__QcqpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__QcqpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QcqpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qcqpSolver_hasPlugin :: String -> IO Bool
-qcqpSolver_hasPlugin = casadi__QcqpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QcqpSolver__loadPlugin" c_casadi__QcqpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__QcqpSolver__loadPlugin
-  :: String -> IO ()
-casadi__QcqpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QcqpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qcqpSolver_loadPlugin :: String -> IO ()
-qcqpSolver_loadPlugin = casadi__QcqpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/QpSolver.hs b/Casadi/Core/Classes/QpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/QpSolver.hs
+++ /dev/null
@@ -1,183 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.QpSolver
-       (
-         QpSolver,
-         QpSolverClass(..),
-         qpSolver__0,
-         qpSolver__1,
-         qpSolver__2,
-         qpSolver_doc,
-         qpSolver_generateNativeCode,
-         qpSolver_hasPlugin,
-         qpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR__0" c_casadi__QpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr QpSolver')
-casadi__QpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO QpSolver
-casadi__QpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qpSolver__0 :: String -> String -> M.Map String Sparsity -> IO QpSolver
-qpSolver__0 = casadi__QpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR__1" c_casadi__QpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr QpSolver')
-casadi__QpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QpSolver
-casadi__QpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QpSolver
-qpSolver__1 = casadi__QpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR__2" c_casadi__QpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr QpSolver')
-casadi__QpSolver__CONSTRUCTOR__2
-  :: IO QpSolver
-casadi__QpSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QpSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qpSolver__2 :: IO QpSolver
-qpSolver__2 = casadi__QpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QpSolver__doc" c_casadi__QpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__QpSolver__doc
-  :: String -> IO String
-casadi__QpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qpSolver_doc :: String -> IO String
-qpSolver_doc = casadi__QpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QpSolver__generateNativeCode" c_casadi__QpSolver__generateNativeCode
-  :: Ptr (Ptr StdString) -> Ptr QpSolver' -> Ptr StdString -> IO ()
-casadi__QpSolver__generateNativeCode
-  :: QpSolver -> String -> IO ()
-casadi__QpSolver__generateNativeCode x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QpSolver__generateNativeCode errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qpSolver_generateNativeCode :: QpSolverClass a => a -> String -> IO ()
-qpSolver_generateNativeCode x = casadi__QpSolver__generateNativeCode (castQpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QpSolver__hasPlugin" c_casadi__QpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__QpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__QpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qpSolver_hasPlugin :: String -> IO Bool
-qpSolver_hasPlugin = casadi__QpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__QpSolver__loadPlugin" c_casadi__QpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__QpSolver__loadPlugin
-  :: String -> IO ()
-casadi__QpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__QpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-qpSolver_loadPlugin :: String -> IO ()
-qpSolver_loadPlugin = casadi__QpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/SX.hs b/Casadi/Core/Classes/SX.hs
--- a/Casadi/Core/Classes/SX.hs
+++ b/Casadi/Core/Classes/SX.hs
@@ -22,3991 +22,5708 @@
          sx__8,
          sx__9,
          sx___nonzero__,
-         sx_append,
-         sx_appendColumns,
-         sx_binary,
-         sx_className,
-         sx_clear,
-         sx_colind,
-         sx_dimString,
-         sx_enlarge__0,
-         sx_enlarge__1,
-         sx_erase__0,
-         sx_erase__1,
-         sx_erase__2,
-         sx_erase__3,
-         sx_eye,
-         sx_find__0,
-         sx_find__1,
-         sx_getColind,
-         sx_getDep__0,
-         sx_getDep__1,
-         sx_getDescription,
-         sx_getElementHash,
-         sx_getEqualityCheckingDepth,
-         sx_getIntValue,
-         sx_getNZ__0,
-         sx_getNZ__1,
-         sx_getNZ__2,
-         sx_getName,
-         sx_getNdeps,
-         sx_getRepresentation,
-         sx_getRow,
-         sx_getSparsity,
-         sx_getSym,
-         sx_getValue__0,
-         sx_getValue__1,
-         sx_get__0,
-         sx_get__1,
-         sx_get__2,
-         sx_get__3,
-         sx_get__4,
-         sx_get__5,
-         sx_get__6,
-         sx_get__7,
-         sx_hasDuplicates,
-         sx_hasNZ,
-         sx_hasNonStructuralZeros,
-         sx_inf__0,
-         sx_inf__1,
-         sx_inf__2,
-         sx_inf__3,
-         sx_inf__4,
-         sx_isCommutative,
-         sx_isConstant,
-         sx_isIdentity,
-         sx_isInteger,
-         sx_isLeaf,
-         sx_isMinusOne,
-         sx_isOne,
-         sx_isRegular,
-         sx_isSlice__0,
-         sx_isSlice__1,
-         sx_isSmooth,
-         sx_isSymbolic,
-         sx_isValidInput,
-         sx_isZero,
-         sx_iscolumn,
-         sx_isdense,
-         sx_isempty__0,
-         sx_isempty__1,
-         sx_isrow,
-         sx_isscalar__0,
-         sx_isscalar__1,
-         sx_issquare,
-         sx_istril,
-         sx_istriu,
-         sx_isvector,
-         sx_makeSparse__0,
-         sx_makeSparse__1,
-         sx_matrix_matrix,
-         sx_matrix_scalar,
-         sx_nan__0,
-         sx_nan__1,
-         sx_nan__2,
-         sx_nan__3,
-         sx_nan__4,
-         sx_nnz,
-         sx_nonzeros,
-         sx_nonzeros_int,
-         sx_numel__0,
-         sx_numel__1,
-         sx_ones__0,
-         sx_ones__1,
-         sx_ones__2,
-         sx_ones__3,
-         sx_ones__4,
-         sx_operator_minus,
-         sx_operator_plus,
-         sx_printDense,
-         sx_printScalar,
-         sx_printSparse,
-         sx_printSplit,
-         sx_printVector,
-         sx_printme,
-         sx_remove,
-         sx_reserve__0,
-         sx_reserve__1,
-         sx_resetInput,
-         sx_resize,
-         sx_row,
-         sx_sanityCheck__0,
-         sx_sanityCheck__1,
-         sx_scalar_matrix,
-         sx_setEqualityCheckingDepth__0,
-         sx_setEqualityCheckingDepth__1,
-         sx_setNZ__0,
-         sx_setNZ__1,
-         sx_setNZ__2,
-         sx_setNZ__3,
-         sx_setPrecision,
-         sx_setScientific,
-         sx_setSym,
-         sx_setValue__0,
-         sx_setValue__1,
-         sx_setWidth,
-         sx_setZero,
-         sx_set__0,
-         sx_set__1,
-         sx_set__10,
-         sx_set__2,
-         sx_set__3,
-         sx_set__4,
-         sx_set__5,
-         sx_set__6,
-         sx_set__7,
-         sx_set__8,
-         sx_set__9,
-         sx_shape__0,
-         sx_shape__1,
-         sx_size,
-         sx_size1,
-         sx_size2,
-         sx_sizeD,
-         sx_sizeL,
-         sx_sizeU,
-         sx_sparse__0,
-         sx_sparse__1,
-         sx_sparse__2,
-         sx_sparse__3,
-         sx_sparse__4,
-         sx_sparsity,
-         sx_sym__0,
-         sx_sym__1,
-         sx_sym__2,
-         sx_sym__3,
-         sx_sym__4,
-         sx_sym__5,
-         sx_sym__6,
-         sx_sym__7,
-         sx_sym__8,
-         sx_toSlice__0,
-         sx_toSlice__1,
-         sx_triplet__0,
-         sx_triplet__1,
-         sx_triplet__2,
-         sx_unary,
-         sx_zeros__0,
-         sx_zeros__1,
-         sx_zeros__2,
-         sx_zeros__3,
-         sx_zeros__4,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__0" c_casadi__SX__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__0
-  :: Vector Double -> IO SX
-casadi__SX__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__0 :: Vector Double -> IO SX
-sx__0 = casadi__SX__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__1" c_casadi__SX__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__1
-  :: DMatrix -> IO SX
-casadi__SX__CONSTRUCTOR__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__1 :: DMatrix -> IO SX
-sx__1 = casadi__SX__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__2" c_casadi__SX__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__2
-  :: Vector Int -> IO SX
-casadi__SX__CONSTRUCTOR__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__2 :: Vector Int -> IO SX
-sx__2 = casadi__SX__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__3" c_casadi__SX__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__3
-  :: IMatrix -> IO SX
-casadi__SX__CONSTRUCTOR__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__3 :: IMatrix -> IO SX
-sx__3 = casadi__SX__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__4" c_casadi__SX__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__4
-  :: Vector (Vector Double) -> IO SX
-casadi__SX__CONSTRUCTOR__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__4 :: Vector (Vector Double) -> IO SX
-sx__4 = casadi__SX__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__5" c_casadi__SX__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__5
-  :: Double -> IO SX
-casadi__SX__CONSTRUCTOR__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__5 :: Double -> IO SX
-sx__5 = casadi__SX__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__6" c_casadi__SX__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__6
-  :: Sparsity -> SX -> IO SX
-casadi__SX__CONSTRUCTOR__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__6 :: Sparsity -> SX -> IO SX
-sx__6 = casadi__SX__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__7" c_casadi__SX__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__7
-  :: Sparsity -> IO SX
-casadi__SX__CONSTRUCTOR__7 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__7 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__7 :: Sparsity -> IO SX
-sx__7 = casadi__SX__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__8" c_casadi__SX__CONSTRUCTOR__8
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__8
-  :: Int -> Int -> IO SX
-casadi__SX__CONSTRUCTOR__8 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__8 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__8 :: Int -> Int -> IO SX
-sx__8 = casadi__SX__CONSTRUCTOR__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__9" c_casadi__SX__CONSTRUCTOR__9
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__9
-  :: SX -> IO SX
-casadi__SX__CONSTRUCTOR__9 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__9 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__9 :: SX -> IO SX
-sx__9 = casadi__SX__CONSTRUCTOR__9
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__10" c_casadi__SX__CONSTRUCTOR__10
-  :: Ptr (Ptr StdString) -> IO (Ptr SX')
-casadi__SX__CONSTRUCTOR__10
-  :: IO SX
-casadi__SX__CONSTRUCTOR__10  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__CONSTRUCTOR__10 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx__10 :: IO SX
-sx__10 = casadi__SX__CONSTRUCTOR__10
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__T" c_casadi__SX__T
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__T
-  :: SX -> IO SX
-casadi__SX__T x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__T errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_T :: SXClass a => a -> IO SX
-sx_T x = casadi__SX__T (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX____nonzero__" c_casadi__SX____nonzero__
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX____nonzero__
-  :: SX -> IO Bool
-casadi__SX____nonzero__ x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX____nonzero__ errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx___nonzero__ :: SXClass a => a -> IO Bool
-sx___nonzero__ x = casadi__SX____nonzero__ (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__append" c_casadi__SX__append
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO ()
-casadi__SX__append
-  :: SX -> SX -> IO ()
-casadi__SX__append x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__append errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_append :: SXClass a => a -> SX -> IO ()
-sx_append x = casadi__SX__append (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__appendColumns" c_casadi__SX__appendColumns
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO ()
-casadi__SX__appendColumns
-  :: SX -> SX -> IO ()
-casadi__SX__appendColumns x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__appendColumns errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_appendColumns :: SXClass a => a -> SX -> IO ()
-sx_appendColumns x = casadi__SX__appendColumns (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__binary" c_casadi__SX__binary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__binary
-  :: Int -> SX -> SX -> IO SX
-casadi__SX__binary x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__binary errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_binary :: Int -> SX -> SX -> IO SX
-sx_binary = casadi__SX__binary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__className" c_casadi__SX__className
-  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
-casadi__SX__className
-  :: IO String
-casadi__SX__className  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__className errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_className :: IO String
-sx_className = casadi__SX__className
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__clear" c_casadi__SX__clear
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__clear
-  :: SX -> IO ()
-casadi__SX__clear x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__clear errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_clear :: SXClass a => a -> IO ()
-sx_clear x = casadi__SX__clear (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__colind" c_casadi__SX__colind
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
-casadi__SX__colind
-  :: SX -> Int -> IO Int
-casadi__SX__colind x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__colind errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_colind :: SXClass a => a -> Int -> IO Int
-sx_colind x = casadi__SX__colind (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__dimString" c_casadi__SX__dimString
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
-casadi__SX__dimString
-  :: SX -> IO String
-casadi__SX__dimString x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__dimString errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_dimString :: SXClass a => a -> IO String
-sx_dimString x = casadi__SX__dimString (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__enlarge__0" c_casadi__SX__enlarge__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__SX__enlarge__0
-  :: SX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-casadi__SX__enlarge__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_enlarge__0 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-sx_enlarge__0 x = casadi__SX__enlarge__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__enlarge__1" c_casadi__SX__enlarge__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__SX__enlarge__1
-  :: SX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__SX__enlarge__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_enlarge__1 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-sx_enlarge__1 x = casadi__SX__enlarge__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__erase__0" c_casadi__SX__erase__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO ()
-casadi__SX__erase__0
-  :: SX -> Vector Int -> IO ()
-casadi__SX__erase__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__erase__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_erase__0 :: SXClass a => a -> Vector Int -> IO ()
-sx_erase__0 x = casadi__SX__erase__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__erase__1" c_casadi__SX__erase__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__SX__erase__1
-  :: SX -> Vector Int -> Bool -> IO ()
-casadi__SX__erase__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__erase__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_erase__1 :: SXClass a => a -> Vector Int -> Bool -> IO ()
-sx_erase__1 x = casadi__SX__erase__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__erase__2" c_casadi__SX__erase__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__SX__erase__2
-  :: SX -> Vector Int -> Vector Int -> IO ()
-casadi__SX__erase__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__erase__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_erase__2 :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
-sx_erase__2 x = casadi__SX__erase__2 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__erase__3" c_casadi__SX__erase__3
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__SX__erase__3
-  :: SX -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__SX__erase__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__erase__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_erase__3 :: SXClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
-sx_erase__3 x = casadi__SX__erase__3 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__eye" c_casadi__SX__eye
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
-casadi__SX__eye
-  :: Int -> IO SX
-casadi__SX__eye x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__eye errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_eye :: Int -> IO SX
-sx_eye = casadi__SX__eye
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__find__0" c_casadi__SX__find__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt))
-casadi__SX__find__0
-  :: SX -> IO (Vector Int)
-casadi__SX__find__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__find__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_find__0 :: SXClass a => a -> IO (Vector Int)
-sx_find__0 x = casadi__SX__find__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__find__1" c_casadi__SX__find__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__SX__find__1
-  :: SX -> Bool -> IO (Vector Int)
-casadi__SX__find__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__find__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_find__1 :: SXClass a => a -> Bool -> IO (Vector Int)
-sx_find__1 x = casadi__SX__find__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__0" c_casadi__SX__get__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__SX__get__0
-  :: SX -> SX -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__SX__get__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IMatrix -> IO ()
-sx_get__0 x = casadi__SX__get__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__1" c_casadi__SX__get__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__SX__get__1
-  :: SX -> SX -> Bool -> IMatrix -> Slice -> IO ()
-casadi__SX__get__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__1 :: SXClass a => a -> SX -> Bool -> IMatrix -> Slice -> IO ()
-sx_get__1 x = casadi__SX__get__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__2" c_casadi__SX__get__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__SX__get__2
-  :: SX -> SX -> Bool -> Slice -> IMatrix -> IO ()
-casadi__SX__get__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__2 :: SXClass a => a -> SX -> Bool -> Slice -> IMatrix -> IO ()
-sx_get__2 x = casadi__SX__get__2 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__3" c_casadi__SX__get__3
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__SX__get__3
-  :: SX -> SX -> Bool -> Slice -> Slice -> IO ()
-casadi__SX__get__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__3 :: SXClass a => a -> SX -> Bool -> Slice -> Slice -> IO ()
-sx_get__3 x = casadi__SX__get__3 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__4" c_casadi__SX__get__4
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__SX__get__4
-  :: SX -> SX -> Bool -> Sparsity -> IO ()
-casadi__SX__get__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__4 :: SXClass a => a -> SX -> Bool -> Sparsity -> IO ()
-sx_get__4 x = casadi__SX__get__4 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__5" c_casadi__SX__get__5
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__SX__get__5
-  :: SX -> SX -> Bool -> IMatrix -> IO ()
-casadi__SX__get__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__5 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO ()
-sx_get__5 x = casadi__SX__get__5 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__6" c_casadi__SX__get__6
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO ()
-casadi__SX__get__6
-  :: SX -> SX -> Bool -> Slice -> IO ()
-casadi__SX__get__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__6 :: SXClass a => a -> SX -> Bool -> Slice -> IO ()
-sx_get__6 x = casadi__SX__get__6 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__get__7" c_casadi__SX__get__7
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__SX__get__7
-  :: SX -> Vector Double -> IO ()
-casadi__SX__get__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__get__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_get__7 :: SXClass a => a -> Vector Double -> IO ()
-sx_get__7 x = casadi__SX__get__7 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getColind" c_casadi__SX__getColind
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt))
-casadi__SX__getColind
-  :: SX -> IO (Vector Int)
-casadi__SX__getColind x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getColind errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getColind :: SXClass a => a -> IO (Vector Int)
-sx_getColind x = casadi__SX__getColind (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getDep__0" c_casadi__SX__getDep__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__getDep__0
-  :: SX -> IO SX
-casadi__SX__getDep__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getDep__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getDep__0 :: SXClass a => a -> IO SX
-sx_getDep__0 x = casadi__SX__getDep__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getDep__1" c_casadi__SX__getDep__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi__SX__getDep__1
-  :: SX -> Int -> IO SX
-casadi__SX__getDep__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getDep__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getDep__1 :: SXClass a => a -> Int -> IO SX
-sx_getDep__1 x = casadi__SX__getDep__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getElementHash" c_casadi__SX__getElementHash
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CSize
-casadi__SX__getElementHash
-  :: SX -> IO CSize
-casadi__SX__getElementHash x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getElementHash errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getElementHash :: SXClass a => a -> IO CSize
-sx_getElementHash x = casadi__SX__getElementHash (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getEqualityCheckingDepth" c_casadi__SX__getEqualityCheckingDepth
-  :: Ptr (Ptr StdString) -> IO CInt
-casadi__SX__getEqualityCheckingDepth
-  :: IO Int
-casadi__SX__getEqualityCheckingDepth  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getEqualityCheckingDepth errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getEqualityCheckingDepth :: IO Int
-sx_getEqualityCheckingDepth = casadi__SX__getEqualityCheckingDepth
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getIntValue" c_casadi__SX__getIntValue
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__getIntValue
-  :: SX -> IO Int
-casadi__SX__getIntValue x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getIntValue errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getIntValue :: SXClass a => a -> IO Int
-sx_getIntValue x = casadi__SX__getIntValue (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getNZ__0" c_casadi__SX__getNZ__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__SX__getNZ__0
-  :: SX -> SX -> Bool -> IMatrix -> IO ()
-casadi__SX__getNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getNZ__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO ()
-sx_getNZ__0 x = casadi__SX__getNZ__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getNZ__1" c_casadi__SX__getNZ__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO ()
-casadi__SX__getNZ__1
-  :: SX -> SX -> Bool -> Slice -> IO ()
-casadi__SX__getNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getNZ__1 :: SXClass a => a -> SX -> Bool -> Slice -> IO ()
-sx_getNZ__1 x = casadi__SX__getNZ__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getNZ__2" c_casadi__SX__getNZ__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__SX__getNZ__2
-  :: SX -> Vector Double -> IO ()
-casadi__SX__getNZ__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getNZ__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getNZ__2 :: SXClass a => a -> Vector Double -> IO ()
-sx_getNZ__2 x = casadi__SX__getNZ__2 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getName" c_casadi__SX__getName
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
-casadi__SX__getName
-  :: SX -> IO String
-casadi__SX__getName x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getName errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getName :: SXClass a => a -> IO String
-sx_getName x = casadi__SX__getName (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getNdeps" c_casadi__SX__getNdeps
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__getNdeps
-  :: SX -> IO Int
-casadi__SX__getNdeps x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getNdeps errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getNdeps :: SXClass a => a -> IO Int
-sx_getNdeps x = casadi__SX__getNdeps (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getRow" c_casadi__SX__getRow
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt))
-casadi__SX__getRow
-  :: SX -> IO (Vector Int)
-casadi__SX__getRow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getRow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getRow :: SXClass a => a -> IO (Vector Int)
-sx_getRow x = casadi__SX__getRow (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getSparsity" c_casadi__SX__getSparsity
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity')
-casadi__SX__getSparsity
-  :: SX -> IO Sparsity
-casadi__SX__getSparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getSparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getSparsity :: SXClass a => a -> IO Sparsity
-sx_getSparsity x = casadi__SX__getSparsity (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getSym" c_casadi__SX__getSym
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__SX__getSym
-  :: SX -> Vector Double -> IO ()
-casadi__SX__getSym x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getSym errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getSym :: SXClass a => a -> Vector Double -> IO ()
-sx_getSym x = casadi__SX__getSym (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getValue__0" c_casadi__SX__getValue__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CDouble
-casadi__SX__getValue__0
-  :: SX -> Int -> IO Double
-casadi__SX__getValue__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getValue__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getValue__0 :: SXClass a => a -> Int -> IO Double
-sx_getValue__0 x = casadi__SX__getValue__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getValue__1" c_casadi__SX__getValue__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CDouble
-casadi__SX__getValue__1
-  :: SX -> IO Double
-casadi__SX__getValue__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getValue__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getValue__1 :: SXClass a => a -> IO Double
-sx_getValue__1 x = casadi__SX__getValue__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__hasDuplicates" c_casadi__SX__hasDuplicates
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__hasDuplicates
-  :: SX -> IO Bool
-casadi__SX__hasDuplicates x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__hasDuplicates errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_hasDuplicates :: SXClass a => a -> IO Bool
-sx_hasDuplicates x = casadi__SX__hasDuplicates (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__hasNZ" c_casadi__SX__hasNZ
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO CInt
-casadi__SX__hasNZ
-  :: SX -> Int -> Int -> IO Bool
-casadi__SX__hasNZ x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__hasNZ errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_hasNZ :: SXClass a => a -> Int -> Int -> IO Bool
-sx_hasNZ x = casadi__SX__hasNZ (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__hasNonStructuralZeros" c_casadi__SX__hasNonStructuralZeros
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__hasNonStructuralZeros
-  :: SX -> IO Bool
-casadi__SX__hasNonStructuralZeros x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__hasNonStructuralZeros errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_hasNonStructuralZeros :: SXClass a => a -> IO Bool
-sx_hasNonStructuralZeros x = casadi__SX__hasNonStructuralZeros (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__inf__0" c_casadi__SX__inf__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi__SX__inf__0
-  :: (Int, Int) -> IO SX
-casadi__SX__inf__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__inf__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_inf__0 :: (Int, Int) -> IO SX
-sx_inf__0 = casadi__SX__inf__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__inf__1" c_casadi__SX__inf__1
-  :: Ptr (Ptr StdString) -> IO (Ptr SX')
-casadi__SX__inf__1
-  :: IO SX
-casadi__SX__inf__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__inf__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_inf__1 :: IO SX
-sx_inf__1 = casadi__SX__inf__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__inf__2" c_casadi__SX__inf__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
-casadi__SX__inf__2
-  :: Int -> IO SX
-casadi__SX__inf__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__inf__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_inf__2 :: Int -> IO SX
-sx_inf__2 = casadi__SX__inf__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__inf__3" c_casadi__SX__inf__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__inf__3
-  :: Int -> Int -> IO SX
-casadi__SX__inf__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__inf__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_inf__3 :: Int -> Int -> IO SX
-sx_inf__3 = casadi__SX__inf__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__inf__4" c_casadi__SX__inf__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
-casadi__SX__inf__4
-  :: Sparsity -> IO SX
-casadi__SX__inf__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__inf__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_inf__4 :: Sparsity -> IO SX
-sx_inf__4 = casadi__SX__inf__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isCommutative" c_casadi__SX__isCommutative
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isCommutative
-  :: SX -> IO Bool
-casadi__SX__isCommutative x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isCommutative errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isCommutative :: SXClass a => a -> IO Bool
-sx_isCommutative x = casadi__SX__isCommutative (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isConstant" c_casadi__SX__isConstant
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isConstant
-  :: SX -> IO Bool
-casadi__SX__isConstant x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isConstant errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isConstant :: SXClass a => a -> IO Bool
-sx_isConstant x = casadi__SX__isConstant (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isIdentity" c_casadi__SX__isIdentity
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isIdentity
-  :: SX -> IO Bool
-casadi__SX__isIdentity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isIdentity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isIdentity :: SXClass a => a -> IO Bool
-sx_isIdentity x = casadi__SX__isIdentity (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isInteger" c_casadi__SX__isInteger
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isInteger
-  :: SX -> IO Bool
-casadi__SX__isInteger x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isInteger errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isInteger :: SXClass a => a -> IO Bool
-sx_isInteger x = casadi__SX__isInteger (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isLeaf" c_casadi__SX__isLeaf
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isLeaf
-  :: SX -> IO Bool
-casadi__SX__isLeaf x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isLeaf errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isLeaf :: SXClass a => a -> IO Bool
-sx_isLeaf x = casadi__SX__isLeaf (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isMinusOne" c_casadi__SX__isMinusOne
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isMinusOne
-  :: SX -> IO Bool
-casadi__SX__isMinusOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isMinusOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isMinusOne :: SXClass a => a -> IO Bool
-sx_isMinusOne x = casadi__SX__isMinusOne (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isOne" c_casadi__SX__isOne
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isOne
-  :: SX -> IO Bool
-casadi__SX__isOne x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isOne errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isOne :: SXClass a => a -> IO Bool
-sx_isOne x = casadi__SX__isOne (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isRegular" c_casadi__SX__isRegular
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isRegular
-  :: SX -> IO Bool
-casadi__SX__isRegular x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isRegular errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isRegular :: SXClass a => a -> IO Bool
-sx_isRegular x = casadi__SX__isRegular (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isSlice__0" c_casadi__SX__isSlice__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isSlice__0
-  :: SX -> IO Bool
-casadi__SX__isSlice__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isSlice__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isSlice__0 :: SXClass a => a -> IO Bool
-sx_isSlice__0 x = casadi__SX__isSlice__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isSlice__1" c_casadi__SX__isSlice__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
-casadi__SX__isSlice__1
-  :: SX -> Bool -> IO Bool
-casadi__SX__isSlice__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isSlice__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isSlice__1 :: SXClass a => a -> Bool -> IO Bool
-sx_isSlice__1 x = casadi__SX__isSlice__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isSmooth" c_casadi__SX__isSmooth
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isSmooth
-  :: SX -> IO Bool
-casadi__SX__isSmooth x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isSmooth errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isSmooth :: SXClass a => a -> IO Bool
-sx_isSmooth x = casadi__SX__isSmooth (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isSymbolic" c_casadi__SX__isSymbolic
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isSymbolic
-  :: SX -> IO Bool
-casadi__SX__isSymbolic x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isSymbolic errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isSymbolic :: SXClass a => a -> IO Bool
-sx_isSymbolic x = casadi__SX__isSymbolic (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isValidInput" c_casadi__SX__isValidInput
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isValidInput
-  :: SX -> IO Bool
-casadi__SX__isValidInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isValidInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isValidInput :: SXClass a => a -> IO Bool
-sx_isValidInput x = casadi__SX__isValidInput (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isZero" c_casadi__SX__isZero
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isZero
-  :: SX -> IO Bool
-casadi__SX__isZero x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isZero errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isZero :: SXClass a => a -> IO Bool
-sx_isZero x = casadi__SX__isZero (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__iscolumn" c_casadi__SX__iscolumn
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__iscolumn
-  :: SX -> IO Bool
-casadi__SX__iscolumn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__iscolumn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_iscolumn :: SXClass a => a -> IO Bool
-sx_iscolumn x = casadi__SX__iscolumn (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isdense" c_casadi__SX__isdense
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isdense
-  :: SX -> IO Bool
-casadi__SX__isdense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isdense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isdense :: SXClass a => a -> IO Bool
-sx_isdense x = casadi__SX__isdense (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isempty__0" c_casadi__SX__isempty__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isempty__0
-  :: SX -> IO Bool
-casadi__SX__isempty__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isempty__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isempty__0 :: SXClass a => a -> IO Bool
-sx_isempty__0 x = casadi__SX__isempty__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isempty__1" c_casadi__SX__isempty__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
-casadi__SX__isempty__1
-  :: SX -> Bool -> IO Bool
-casadi__SX__isempty__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isempty__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isempty__1 :: SXClass a => a -> Bool -> IO Bool
-sx_isempty__1 x = casadi__SX__isempty__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isrow" c_casadi__SX__isrow
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isrow
-  :: SX -> IO Bool
-casadi__SX__isrow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isrow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isrow :: SXClass a => a -> IO Bool
-sx_isrow x = casadi__SX__isrow (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isscalar__0" c_casadi__SX__isscalar__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isscalar__0
-  :: SX -> IO Bool
-casadi__SX__isscalar__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isscalar__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isscalar__0 :: SXClass a => a -> IO Bool
-sx_isscalar__0 x = casadi__SX__isscalar__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isscalar__1" c_casadi__SX__isscalar__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
-casadi__SX__isscalar__1
-  :: SX -> Bool -> IO Bool
-casadi__SX__isscalar__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isscalar__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isscalar__1 :: SXClass a => a -> Bool -> IO Bool
-sx_isscalar__1 x = casadi__SX__isscalar__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__issquare" c_casadi__SX__issquare
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__issquare
-  :: SX -> IO Bool
-casadi__SX__issquare x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__issquare errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_issquare :: SXClass a => a -> IO Bool
-sx_issquare x = casadi__SX__issquare (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__istril" c_casadi__SX__istril
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__istril
-  :: SX -> IO Bool
-casadi__SX__istril x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__istril errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_istril :: SXClass a => a -> IO Bool
-sx_istril x = casadi__SX__istril (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__istriu" c_casadi__SX__istriu
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__istriu
-  :: SX -> IO Bool
-casadi__SX__istriu x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__istriu errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_istriu :: SXClass a => a -> IO Bool
-sx_istriu x = casadi__SX__istriu (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__isvector" c_casadi__SX__isvector
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__isvector
-  :: SX -> IO Bool
-casadi__SX__isvector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__isvector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_isvector :: SXClass a => a -> IO Bool
-sx_isvector x = casadi__SX__isvector (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__makeSparse__0" c_casadi__SX__makeSparse__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__makeSparse__0
-  :: SX -> IO ()
-casadi__SX__makeSparse__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__makeSparse__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_makeSparse__0 :: SXClass a => a -> IO ()
-sx_makeSparse__0 x = casadi__SX__makeSparse__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__makeSparse__1" c_casadi__SX__makeSparse__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO ()
-casadi__SX__makeSparse__1
-  :: SX -> Double -> IO ()
-casadi__SX__makeSparse__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__makeSparse__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_makeSparse__1 :: SXClass a => a -> Double -> IO ()
-sx_makeSparse__1 x = casadi__SX__makeSparse__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__matrix_matrix" c_casadi__SX__matrix_matrix
-  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__matrix_matrix
-  :: Int -> SX -> SX -> IO SX
-casadi__SX__matrix_matrix x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__matrix_matrix errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_matrix_matrix :: Int -> SX -> SX -> IO SX
-sx_matrix_matrix = casadi__SX__matrix_matrix
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__matrix_scalar" c_casadi__SX__matrix_scalar
-  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__matrix_scalar
-  :: Int -> SX -> SX -> IO SX
-casadi__SX__matrix_scalar x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__matrix_scalar errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_matrix_scalar :: Int -> SX -> SX -> IO SX
-sx_matrix_scalar = casadi__SX__matrix_scalar
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nan__0" c_casadi__SX__nan__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi__SX__nan__0
-  :: (Int, Int) -> IO SX
-casadi__SX__nan__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nan__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nan__0 :: (Int, Int) -> IO SX
-sx_nan__0 = casadi__SX__nan__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nan__1" c_casadi__SX__nan__1
-  :: Ptr (Ptr StdString) -> IO (Ptr SX')
-casadi__SX__nan__1
-  :: IO SX
-casadi__SX__nan__1  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nan__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nan__1 :: IO SX
-sx_nan__1 = casadi__SX__nan__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nan__2" c_casadi__SX__nan__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
-casadi__SX__nan__2
-  :: Int -> IO SX
-casadi__SX__nan__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nan__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nan__2 :: Int -> IO SX
-sx_nan__2 = casadi__SX__nan__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nan__3" c_casadi__SX__nan__3
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__nan__3
-  :: Int -> Int -> IO SX
-casadi__SX__nan__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nan__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nan__3 :: Int -> Int -> IO SX
-sx_nan__3 = casadi__SX__nan__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nan__4" c_casadi__SX__nan__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
-casadi__SX__nan__4
-  :: Sparsity -> IO SX
-casadi__SX__nan__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nan__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nan__4 :: Sparsity -> IO SX
-sx_nan__4 = casadi__SX__nan__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nnz" c_casadi__SX__nnz
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__nnz
-  :: SX -> IO Int
-casadi__SX__nnz x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nnz errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nnz :: SXClass a => a -> IO Int
-sx_nnz x = casadi__SX__nnz (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nonzeros" c_casadi__SX__nonzeros
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CDouble))
-casadi__SX__nonzeros
-  :: SX -> IO (Vector Double)
-casadi__SX__nonzeros x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nonzeros errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nonzeros :: SXClass a => a -> IO (Vector Double)
-sx_nonzeros x = casadi__SX__nonzeros (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__nonzeros_int" c_casadi__SX__nonzeros_int
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt))
-casadi__SX__nonzeros_int
-  :: SX -> IO (Vector Int)
-casadi__SX__nonzeros_int x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__nonzeros_int errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_nonzeros_int :: SXClass a => a -> IO (Vector Int)
-sx_nonzeros_int x = casadi__SX__nonzeros_int (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__numel__0" c_casadi__SX__numel__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
-casadi__SX__numel__0
-  :: SX -> Int -> IO Int
-casadi__SX__numel__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__numel__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_numel__0 :: SXClass a => a -> Int -> IO Int
-sx_numel__0 x = casadi__SX__numel__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__numel__1" c_casadi__SX__numel__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__numel__1
-  :: SX -> IO Int
-casadi__SX__numel__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__numel__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_numel__1 :: SXClass a => a -> IO Int
-sx_numel__1 x = casadi__SX__numel__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__ones__0" c_casadi__SX__ones__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi__SX__ones__0
-  :: (Int, Int) -> IO SX
-casadi__SX__ones__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__ones__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_ones__0 :: (Int, Int) -> IO SX
-sx_ones__0 = casadi__SX__ones__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__ones__1" c_casadi__SX__ones__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
-casadi__SX__ones__1
-  :: Sparsity -> IO SX
-casadi__SX__ones__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__ones__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_ones__1 :: Sparsity -> IO SX
-sx_ones__1 = casadi__SX__ones__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__ones__2" c_casadi__SX__ones__2
-  :: Ptr (Ptr StdString) -> IO (Ptr SX')
-casadi__SX__ones__2
-  :: IO SX
-casadi__SX__ones__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__ones__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_ones__2 :: IO SX
-sx_ones__2 = casadi__SX__ones__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__ones__3" c_casadi__SX__ones__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
-casadi__SX__ones__3
-  :: Int -> IO SX
-casadi__SX__ones__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__ones__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_ones__3 :: Int -> IO SX
-sx_ones__3 = casadi__SX__ones__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__ones__4" c_casadi__SX__ones__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__ones__4
-  :: Int -> Int -> IO SX
-casadi__SX__ones__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__ones__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_ones__4 :: Int -> Int -> IO SX
-sx_ones__4 = casadi__SX__ones__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__operator_plus" c_casadi__SX__operator_plus
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__operator_plus
-  :: SX -> IO SX
-casadi__SX__operator_plus x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__operator_plus errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_operator_plus :: SXClass a => a -> IO SX
-sx_operator_plus x = casadi__SX__operator_plus (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__operator_minus" c_casadi__SX__operator_minus
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__operator_minus
-  :: SX -> IO SX
-casadi__SX__operator_minus x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__operator_minus errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_operator_minus :: SXClass a => a -> IO SX
-sx_operator_minus x = casadi__SX__operator_minus (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__printDense" c_casadi__SX__printDense
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__printDense
-  :: SX -> IO ()
-casadi__SX__printDense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__printDense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_printDense :: SXClass a => a -> IO ()
-sx_printDense x = casadi__SX__printDense (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__printScalar" c_casadi__SX__printScalar
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__printScalar
-  :: SX -> IO ()
-casadi__SX__printScalar x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__printScalar errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_printScalar :: SXClass a => a -> IO ()
-sx_printScalar x = casadi__SX__printScalar (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__printSparse" c_casadi__SX__printSparse
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__printSparse
-  :: SX -> IO ()
-casadi__SX__printSparse x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__printSparse errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_printSparse :: SXClass a => a -> IO ()
-sx_printSparse x = casadi__SX__printSparse (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__printSplit" c_casadi__SX__printSplit
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO ()
-casadi__SX__printSplit
-  :: SX -> Vector String -> Vector String -> IO ()
-casadi__SX__printSplit x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__printSplit errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_printSplit :: SXClass a => a -> Vector String -> Vector String -> IO ()
-sx_printSplit x = casadi__SX__printSplit (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__printVector" c_casadi__SX__printVector
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__printVector
-  :: SX -> IO ()
-casadi__SX__printVector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__printVector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_printVector :: SXClass a => a -> IO ()
-sx_printVector x = casadi__SX__printVector (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__printme" c_casadi__SX__printme
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__printme
-  :: SX -> SX -> IO SX
-casadi__SX__printme x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__printme errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_printme :: SXClass a => a -> SX -> IO SX
-sx_printme x = casadi__SX__printme (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__remove" c_casadi__SX__remove
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__SX__remove
-  :: SX -> Vector Int -> Vector Int -> IO ()
-casadi__SX__remove x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__remove errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_remove :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
-sx_remove x = casadi__SX__remove (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__reserve__0" c_casadi__SX__reserve__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO ()
-casadi__SX__reserve__0
-  :: SX -> Int -> Int -> IO ()
-casadi__SX__reserve__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__reserve__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_reserve__0 :: SXClass a => a -> Int -> Int -> IO ()
-sx_reserve__0 x = casadi__SX__reserve__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__reserve__1" c_casadi__SX__reserve__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO ()
-casadi__SX__reserve__1
-  :: SX -> Int -> IO ()
-casadi__SX__reserve__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__reserve__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_reserve__1 :: SXClass a => a -> Int -> IO ()
-sx_reserve__1 x = casadi__SX__reserve__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__resetInput" c_casadi__SX__resetInput
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__resetInput
-  :: SX -> IO ()
-casadi__SX__resetInput x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__resetInput errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_resetInput :: SXClass a => a -> IO ()
-sx_resetInput x = casadi__SX__resetInput (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__resize" c_casadi__SX__resize
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO ()
-casadi__SX__resize
-  :: SX -> Int -> Int -> IO ()
-casadi__SX__resize x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__resize errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_resize :: SXClass a => a -> Int -> Int -> IO ()
-sx_resize x = casadi__SX__resize (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__row" c_casadi__SX__row
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
-casadi__SX__row
-  :: SX -> Int -> IO Int
-casadi__SX__row x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__row errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_row :: SXClass a => a -> Int -> IO Int
-sx_row x = casadi__SX__row (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sanityCheck__0" c_casadi__SX__sanityCheck__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__sanityCheck__0
-  :: SX -> IO ()
-casadi__SX__sanityCheck__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sanityCheck__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sanityCheck__0 :: SXClass a => a -> IO ()
-sx_sanityCheck__0 x = casadi__SX__sanityCheck__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sanityCheck__1" c_casadi__SX__sanityCheck__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO ()
-casadi__SX__sanityCheck__1
-  :: SX -> Bool -> IO ()
-casadi__SX__sanityCheck__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sanityCheck__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sanityCheck__1 :: SXClass a => a -> Bool -> IO ()
-sx_sanityCheck__1 x = casadi__SX__sanityCheck__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__scalar_matrix" c_casadi__SX__scalar_matrix
-  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__scalar_matrix
-  :: Int -> SX -> SX -> IO SX
-casadi__SX__scalar_matrix x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__scalar_matrix errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_scalar_matrix :: Int -> SX -> SX -> IO SX
-sx_scalar_matrix = casadi__SX__scalar_matrix
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__0" c_casadi__SX__set__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi__SX__set__0
-  :: SX -> SX -> Bool -> IMatrix -> IMatrix -> IO ()
-casadi__SX__set__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IMatrix -> IO ()
-sx_set__0 x = casadi__SX__set__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__1" c_casadi__SX__set__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO ()
-casadi__SX__set__1
-  :: SX -> SX -> Bool -> IMatrix -> Slice -> IO ()
-casadi__SX__set__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__1 :: SXClass a => a -> SX -> Bool -> IMatrix -> Slice -> IO ()
-sx_set__1 x = casadi__SX__set__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__2" c_casadi__SX__set__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO ()
-casadi__SX__set__2
-  :: SX -> SX -> Bool -> Slice -> IMatrix -> IO ()
-casadi__SX__set__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__2 :: SXClass a => a -> SX -> Bool -> Slice -> IMatrix -> IO ()
-sx_set__2 x = casadi__SX__set__2 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__3" c_casadi__SX__set__3
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
-casadi__SX__set__3
-  :: SX -> SX -> Bool -> Slice -> Slice -> IO ()
-casadi__SX__set__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__3 :: SXClass a => a -> SX -> Bool -> Slice -> Slice -> IO ()
-sx_set__3 x = casadi__SX__set__3 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__4" c_casadi__SX__set__4
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Sparsity' -> IO ()
-casadi__SX__set__4
-  :: SX -> SX -> Bool -> Sparsity -> IO ()
-casadi__SX__set__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__4 :: SXClass a => a -> SX -> Bool -> Sparsity -> IO ()
-sx_set__4 x = casadi__SX__set__4 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__5" c_casadi__SX__set__5
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__SX__set__5
-  :: SX -> SX -> Bool -> IMatrix -> IO ()
-casadi__SX__set__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__5 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO ()
-sx_set__5 x = casadi__SX__set__5 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__6" c_casadi__SX__set__6
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO ()
-casadi__SX__set__6
-  :: SX -> SX -> Bool -> Slice -> IO ()
-casadi__SX__set__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__6 :: SXClass a => a -> SX -> Bool -> Slice -> IO ()
-sx_set__6 x = casadi__SX__set__6 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__7" c_casadi__SX__set__7
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__SX__set__7
-  :: SX -> Vector Double -> IO ()
-casadi__SX__set__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__7 :: SXClass a => a -> Vector Double -> IO ()
-sx_set__7 x = casadi__SX__set__7 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__8" c_casadi__SX__set__8
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
-casadi__SX__set__8
-  :: SX -> Vector Double -> Bool -> IO ()
-casadi__SX__set__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__8 :: SXClass a => a -> Vector Double -> Bool -> IO ()
-sx_set__8 x = casadi__SX__set__8 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__9" c_casadi__SX__set__9
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO ()
-casadi__SX__set__9
-  :: SX -> Double -> IO ()
-casadi__SX__set__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__9 :: SXClass a => a -> Double -> IO ()
-sx_set__9 x = casadi__SX__set__9 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__set__10" c_casadi__SX__set__10
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO ()
-casadi__SX__set__10
-  :: SX -> SX -> IO ()
-casadi__SX__set__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__set__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_set__10 :: SXClass a => a -> SX -> IO ()
-sx_set__10 x = casadi__SX__set__10 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__0" c_casadi__SX__setEqualityCheckingDepth__0
-  :: Ptr (Ptr StdString) -> IO ()
-casadi__SX__setEqualityCheckingDepth__0
-  :: IO ()
-casadi__SX__setEqualityCheckingDepth__0  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setEqualityCheckingDepth__0 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setEqualityCheckingDepth__0 :: IO ()
-sx_setEqualityCheckingDepth__0 = casadi__SX__setEqualityCheckingDepth__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__1" c_casadi__SX__setEqualityCheckingDepth__1
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__SX__setEqualityCheckingDepth__1
-  :: Int -> IO ()
-casadi__SX__setEqualityCheckingDepth__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setEqualityCheckingDepth__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setEqualityCheckingDepth__1 :: Int -> IO ()
-sx_setEqualityCheckingDepth__1 = casadi__SX__setEqualityCheckingDepth__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setNZ__0" c_casadi__SX__setNZ__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO ()
-casadi__SX__setNZ__0
-  :: SX -> SX -> Bool -> IMatrix -> IO ()
-casadi__SX__setNZ__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setNZ__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setNZ__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO ()
-sx_setNZ__0 x = casadi__SX__setNZ__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setNZ__1" c_casadi__SX__setNZ__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO ()
-casadi__SX__setNZ__1
-  :: SX -> SX -> Bool -> Slice -> IO ()
-casadi__SX__setNZ__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setNZ__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setNZ__1 :: SXClass a => a -> SX -> Bool -> Slice -> IO ()
-sx_setNZ__1 x = casadi__SX__setNZ__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setNZ__2" c_casadi__SX__setNZ__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__SX__setNZ__2
-  :: SX -> Vector Double -> IO ()
-casadi__SX__setNZ__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setNZ__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setNZ__2 :: SXClass a => a -> Vector Double -> IO ()
-sx_setNZ__2 x = casadi__SX__setNZ__2 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setNZ__3" c_casadi__SX__setNZ__3
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO ()
-casadi__SX__setNZ__3
-  :: SX -> Double -> IO ()
-casadi__SX__setNZ__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setNZ__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setNZ__3 :: SXClass a => a -> Double -> IO ()
-sx_setNZ__3 x = casadi__SX__setNZ__3 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setPrecision" c_casadi__SX__setPrecision
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__SX__setPrecision
-  :: Int -> IO ()
-casadi__SX__setPrecision x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setPrecision errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setPrecision :: Int -> IO ()
-sx_setPrecision = casadi__SX__setPrecision
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setScientific" c_casadi__SX__setScientific
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__SX__setScientific
-  :: Bool -> IO ()
-casadi__SX__setScientific x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setScientific errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setScientific :: Bool -> IO ()
-sx_setScientific = casadi__SX__setScientific
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setSym" c_casadi__SX__setSym
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
-casadi__SX__setSym
-  :: SX -> Vector Double -> IO ()
-casadi__SX__setSym x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setSym errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setSym :: SXClass a => a -> Vector Double -> IO ()
-sx_setSym x = casadi__SX__setSym (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setValue__0" c_casadi__SX__setValue__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> CInt -> IO ()
-casadi__SX__setValue__0
-  :: SX -> Double -> Int -> IO ()
-casadi__SX__setValue__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setValue__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setValue__0 :: SXClass a => a -> Double -> Int -> IO ()
-sx_setValue__0 x = casadi__SX__setValue__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setValue__1" c_casadi__SX__setValue__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO ()
-casadi__SX__setValue__1
-  :: SX -> Double -> IO ()
-casadi__SX__setValue__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setValue__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setValue__1 :: SXClass a => a -> Double -> IO ()
-sx_setValue__1 x = casadi__SX__setValue__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setWidth" c_casadi__SX__setWidth
-  :: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__SX__setWidth
-  :: Int -> IO ()
-casadi__SX__setWidth x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setWidth errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setWidth :: Int -> IO ()
-sx_setWidth = casadi__SX__setWidth
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__setZero" c_casadi__SX__setZero
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-casadi__SX__setZero
-  :: SX -> IO ()
-casadi__SX__setZero x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__setZero errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_setZero :: SXClass a => a -> IO ()
-sx_setZero x = casadi__SX__setZero (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__shape__0" c_casadi__SX__shape__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
-casadi__SX__shape__0
-  :: SX -> Int -> IO Int
-casadi__SX__shape__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__shape__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_shape__0 :: SXClass a => a -> Int -> IO Int
-sx_shape__0 x = casadi__SX__shape__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__shape__1" c_casadi__SX__shape__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdPair CInt CInt))
-casadi__SX__shape__1
-  :: SX -> IO (Int, Int)
-casadi__SX__shape__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__shape__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_shape__1 :: SXClass a => a -> IO (Int, Int)
-sx_shape__1 x = casadi__SX__shape__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__size" c_casadi__SX__size
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__size
-  :: SX -> IO Int
-casadi__SX__size x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__size errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_size :: SXClass a => a -> IO Int
-sx_size x = casadi__SX__size (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__size1" c_casadi__SX__size1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__size1
-  :: SX -> IO Int
-casadi__SX__size1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__size1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_size1 :: SXClass a => a -> IO Int
-sx_size1 x = casadi__SX__size1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__size2" c_casadi__SX__size2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__size2
-  :: SX -> IO Int
-casadi__SX__size2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__size2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_size2 :: SXClass a => a -> IO Int
-sx_size2 x = casadi__SX__size2 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sizeD" c_casadi__SX__sizeD
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__sizeD
-  :: SX -> IO Int
-casadi__SX__sizeD x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sizeD errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sizeD :: SXClass a => a -> IO Int
-sx_sizeD x = casadi__SX__sizeD (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sizeL" c_casadi__SX__sizeL
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__sizeL
-  :: SX -> IO Int
-casadi__SX__sizeL x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sizeL errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sizeL :: SXClass a => a -> IO Int
-sx_sizeL x = casadi__SX__sizeL (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sizeU" c_casadi__SX__sizeU
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi__SX__sizeU
-  :: SX -> IO Int
-casadi__SX__sizeU x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sizeU errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sizeU :: SXClass a => a -> IO Int
-sx_sizeU x = casadi__SX__sizeU (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sparse__0" c_casadi__SX__sparse__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__sparse__0
-  :: Sparsity -> SX -> IO SX
-casadi__SX__sparse__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sparse__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sparse__0 :: Sparsity -> SX -> IO SX
-sx_sparse__0 = casadi__SX__sparse__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sparse__1" c_casadi__SX__sparse__1
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi__SX__sparse__1
-  :: (Int, Int) -> IO SX
-casadi__SX__sparse__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sparse__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sparse__1 :: (Int, Int) -> IO SX
-sx_sparse__1 = casadi__SX__sparse__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sparse__2" c_casadi__SX__sparse__2
-  :: Ptr (Ptr StdString) -> IO (Ptr SX')
-casadi__SX__sparse__2
-  :: IO SX
-casadi__SX__sparse__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sparse__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sparse__2 :: IO SX
-sx_sparse__2 = casadi__SX__sparse__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sparse__3" c_casadi__SX__sparse__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
-casadi__SX__sparse__3
-  :: Int -> IO SX
-casadi__SX__sparse__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sparse__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sparse__3 :: Int -> IO SX
-sx_sparse__3 = casadi__SX__sparse__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sparse__4" c_casadi__SX__sparse__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__sparse__4
-  :: Int -> Int -> IO SX
-casadi__SX__sparse__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sparse__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sparse__4 :: Int -> Int -> IO SX
-sx_sparse__4 = casadi__SX__sparse__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sparsity" c_casadi__SX__sparsity
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity')
-casadi__SX__sparsity
-  :: SX -> IO Sparsity
-casadi__SX__sparsity x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sparsity errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sparsity :: SXClass a => a -> IO Sparsity
-sx_sparsity x = casadi__SX__sparsity (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__0" c_casadi__SX__sym__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-casadi__SX__sym__0
-  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX))
-casadi__SX__sym__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX))
-sx_sym__0 = casadi__SX__sym__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__1" c_casadi__SX__sym__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-casadi__SX__sym__1
-  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX))
-casadi__SX__sym__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX))
-sx_sym__1 = casadi__SX__sym__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__2" c_casadi__SX__sym__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi__SX__sym__2
-  :: String -> Int -> Int -> Int -> IO (Vector SX)
-casadi__SX__sym__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector SX)
-sx_sym__2 = casadi__SX__sym__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__3" c_casadi__SX__sym__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi__SX__sym__3
-  :: String -> Sparsity -> Int -> IO (Vector SX)
-casadi__SX__sym__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__3 :: String -> Sparsity -> Int -> IO (Vector SX)
-sx_sym__3 = casadi__SX__sym__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__4" c_casadi__SX__sym__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr SX')
-casadi__SX__sym__4
-  :: String -> Sparsity -> IO SX
-casadi__SX__sym__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__4 :: String -> Sparsity -> IO SX
-sx_sym__4 = casadi__SX__sym__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__5" c_casadi__SX__sym__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi__SX__sym__5
-  :: String -> (Int, Int) -> IO SX
-casadi__SX__sym__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__5 :: String -> (Int, Int) -> IO SX
-sx_sym__5 = casadi__SX__sym__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__6" c_casadi__SX__sym__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr SX')
-casadi__SX__sym__6
-  :: String -> IO SX
-casadi__SX__sym__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__6 :: String -> IO SX
-sx_sym__6 = casadi__SX__sym__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__7" c_casadi__SX__sym__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr SX')
-casadi__SX__sym__7
-  :: String -> Int -> IO SX
-casadi__SX__sym__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__7 :: String -> Int -> IO SX
-sx_sym__7 = casadi__SX__sym__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__sym__8" c_casadi__SX__sym__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__sym__8
-  :: String -> Int -> Int -> IO SX
-casadi__SX__sym__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__sym__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_sym__8 :: String -> Int -> Int -> IO SX
-sx_sym__8 = casadi__SX__sym__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__toSlice__0" c_casadi__SX__toSlice__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Slice')
-casadi__SX__toSlice__0
-  :: SX -> IO Slice
-casadi__SX__toSlice__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__toSlice__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_toSlice__0 :: SXClass a => a -> IO Slice
-sx_toSlice__0 x = casadi__SX__toSlice__0 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__toSlice__1" c_casadi__SX__toSlice__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr Slice')
-casadi__SX__toSlice__1
-  :: SX -> Bool -> IO Slice
-casadi__SX__toSlice__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__toSlice__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_toSlice__1 :: SXClass a => a -> Bool -> IO Slice
-sx_toSlice__1 x = casadi__SX__toSlice__1 (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__triplet__0" c_casadi__SX__triplet__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi__SX__triplet__0
-  :: Vector Int -> Vector Int -> SX -> (Int, Int) -> IO SX
-casadi__SX__triplet__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__triplet__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_triplet__0 :: Vector Int -> Vector Int -> SX -> (Int, Int) -> IO SX
-sx_triplet__0 = casadi__SX__triplet__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__triplet__1" c_casadi__SX__triplet__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__triplet__1
-  :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX
-casadi__SX__triplet__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_triplet__1 :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX
-sx_triplet__1 = casadi__SX__triplet__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__triplet__2" c_casadi__SX__triplet__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__triplet__2
-  :: Vector Int -> Vector Int -> SX -> IO SX
-casadi__SX__triplet__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__triplet__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_triplet__2 :: Vector Int -> Vector Int -> SX -> IO SX
-sx_triplet__2 = casadi__SX__triplet__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__unary" c_casadi__SX__unary
-  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> IO (Ptr SX')
-casadi__SX__unary
-  :: Int -> SX -> IO SX
-casadi__SX__unary x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__unary errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_unary :: Int -> SX -> IO SX
-sx_unary = casadi__SX__unary
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__zeros__0" c_casadi__SX__zeros__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi__SX__zeros__0
-  :: (Int, Int) -> IO SX
-casadi__SX__zeros__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__zeros__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_zeros__0 :: (Int, Int) -> IO SX
-sx_zeros__0 = casadi__SX__zeros__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__zeros__1" c_casadi__SX__zeros__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
-casadi__SX__zeros__1
-  :: Sparsity -> IO SX
-casadi__SX__zeros__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__zeros__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_zeros__1 :: Sparsity -> IO SX
-sx_zeros__1 = casadi__SX__zeros__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__zeros__2" c_casadi__SX__zeros__2
-  :: Ptr (Ptr StdString) -> IO (Ptr SX')
-casadi__SX__zeros__2
-  :: IO SX
-casadi__SX__zeros__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__zeros__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_zeros__2 :: IO SX
-sx_zeros__2 = casadi__SX__zeros__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__zeros__3" c_casadi__SX__zeros__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
-casadi__SX__zeros__3
-  :: Int -> IO SX
-casadi__SX__zeros__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__zeros__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_zeros__3 :: Int -> IO SX
-sx_zeros__3 = casadi__SX__zeros__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__zeros__4" c_casadi__SX__zeros__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
-casadi__SX__zeros__4
-  :: Int -> Int -> IO SX
-casadi__SX__zeros__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__zeros__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_zeros__4 :: Int -> Int -> IO SX
-sx_zeros__4 = casadi__SX__zeros__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getRepresentation" c_casadi__SX__getRepresentation
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
-casadi__SX__getRepresentation
-  :: SX -> IO String
-casadi__SX__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sx_getRepresentation :: SXClass a => a -> IO String
-sx_getRepresentation x = casadi__SX__getRepresentation (castSX x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SX__getDescription" c_casadi__SX__getDescription
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
-casadi__SX__getDescription
-  :: SX -> IO String
-casadi__SX__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SX__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+         sx_binary,
+         sx_clear,
+         sx_colind,
+         sx_dep__0,
+         sx_dep__1,
+         sx_dim,
+         sx_element_hash,
+         sx_enlarge__0,
+         sx_enlarge__1,
+         sx_erase__0,
+         sx_erase__1,
+         sx_erase__2,
+         sx_erase__3,
+         sx_eye,
+         sx_getDescription,
+         sx_getEqualityCheckingDepth,
+         sx_getRepresentation,
+         sx_get__0,
+         sx_get__1,
+         sx_get__2,
+         sx_get__3,
+         sx_get__4,
+         sx_get__5,
+         sx_get__6,
+         sx_get_colind,
+         sx_get_input,
+         sx_get_nonzeros,
+         sx_get_nz__0,
+         sx_get_nz__1,
+         sx_get_row,
+         sx_get_sparsity,
+         sx_grad__0,
+         sx_grad__1,
+         sx_grad__2,
+         sx_grad__3,
+         sx_grad__4,
+         sx_grad__5,
+         sx_grad__6,
+         sx_has_duplicates,
+         sx_has_nz,
+         sx_has_zeros,
+         sx_hess__0,
+         sx_hess__1,
+         sx_hess__2,
+         sx_hess__3,
+         sx_hess__4,
+         sx_hess__5,
+         sx_hess__6,
+         sx_inf__0,
+         sx_inf__1,
+         sx_inf__2,
+         sx_inf__3,
+         sx_inf__4,
+         sx_is_column,
+         sx_is_commutative,
+         sx_is_constant,
+         sx_is_dense,
+         sx_is_empty__0,
+         sx_is_empty__1,
+         sx_is_identity,
+         sx_is_integer,
+         sx_is_leaf,
+         sx_is_minus_one,
+         sx_is_one,
+         sx_is_regular,
+         sx_is_row,
+         sx_is_scalar__0,
+         sx_is_scalar__1,
+         sx_is_smooth,
+         sx_is_square,
+         sx_is_symbolic,
+         sx_is_tril,
+         sx_is_triu,
+         sx_is_valid_input,
+         sx_is_vector,
+         sx_is_zero,
+         sx_jac__0,
+         sx_jac__1,
+         sx_jac__10,
+         sx_jac__11,
+         sx_jac__12,
+         sx_jac__13,
+         sx_jac__14,
+         sx_jac__2,
+         sx_jac__3,
+         sx_jac__4,
+         sx_jac__5,
+         sx_jac__6,
+         sx_jac__7,
+         sx_jac__8,
+         sx_jac__9,
+         sx_matrix_matrix,
+         sx_matrix_scalar,
+         sx_n_dep,
+         sx_name,
+         sx_nan__0,
+         sx_nan__1,
+         sx_nan__2,
+         sx_nan__3,
+         sx_nan__4,
+         sx_nnz,
+         sx_nnz_diag,
+         sx_nnz_lower,
+         sx_nnz_upper,
+         sx_numel__0,
+         sx_numel__1,
+         sx_ones__0,
+         sx_ones__1,
+         sx_ones__2,
+         sx_ones__3,
+         sx_ones__4,
+         sx_operator__minus,
+         sx_operator__plus,
+         sx_operator_double,
+         sx_operator_int,
+         sx_print_dense,
+         sx_print_scalar,
+         sx_print_sparse,
+         sx_print_split,
+         sx_print_vector,
+         sx_printme,
+         sx_remove,
+         sx_reserve__0,
+         sx_reserve__1,
+         sx_resetInput,
+         sx_resize,
+         sx_row,
+         sx_sanity_check__0,
+         sx_sanity_check__1,
+         sx_scalar_matrix,
+         sx_setEqualityCheckingDepth__0,
+         sx_setEqualityCheckingDepth__1,
+         sx_setPrecision,
+         sx_setScientific,
+         sx_setWidth,
+         sx_set__0,
+         sx_set__1,
+         sx_set__2,
+         sx_set__3,
+         sx_set__4,
+         sx_set__5,
+         sx_set__6,
+         sx_set_nz__0,
+         sx_set_nz__1,
+         sx_size1,
+         sx_size2,
+         sx_size__0,
+         sx_size__1,
+         sx_sparsity,
+         sx_sym__0,
+         sx_sym__1,
+         sx_sym__2,
+         sx_sym__3,
+         sx_sym__4,
+         sx_sym__5,
+         sx_sym__6,
+         sx_sym__7,
+         sx_sym__8,
+         sx_tang__0,
+         sx_tang__1,
+         sx_tang__2,
+         sx_tang__3,
+         sx_tang__4,
+         sx_tang__5,
+         sx_tang__6,
+         sx_triplet__0,
+         sx_triplet__1,
+         sx_triplet__2,
+         sx_type_name,
+         sx_unary,
+         sx_zeros__0,
+         sx_zeros__1,
+         sx_zeros__2,
+         sx_zeros__3,
+         sx_zeros__4,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__0" c_casadi__SX__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__0
+  :: Vector Double -> IO SX
+casadi__SX__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__0 :: Vector Double -> IO SX
+sx__0 = casadi__SX__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__1" c_casadi__SX__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__1
+  :: DM -> IO SX
+casadi__SX__CONSTRUCTOR__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__1 :: DM -> IO SX
+sx__1 = casadi__SX__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__2" c_casadi__SX__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__2
+  :: Vector Int -> IO SX
+casadi__SX__CONSTRUCTOR__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__2 :: Vector Int -> IO SX
+sx__2 = casadi__SX__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__3" c_casadi__SX__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__3
+  :: IM -> IO SX
+casadi__SX__CONSTRUCTOR__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__3 :: IM -> IO SX
+sx__3 = casadi__SX__CONSTRUCTOR__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__4" c_casadi__SX__CONSTRUCTOR__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__4
+  :: Vector (Vector Double) -> IO SX
+casadi__SX__CONSTRUCTOR__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__4 :: Vector (Vector Double) -> IO SX
+sx__4 = casadi__SX__CONSTRUCTOR__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__5" c_casadi__SX__CONSTRUCTOR__5
+  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__5
+  :: Double -> IO SX
+casadi__SX__CONSTRUCTOR__5 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__5 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__5 :: Double -> IO SX
+sx__5 = casadi__SX__CONSTRUCTOR__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__6" c_casadi__SX__CONSTRUCTOR__6
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__6
+  :: Sparsity -> SX -> IO SX
+casadi__SX__CONSTRUCTOR__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__6 :: Sparsity -> SX -> IO SX
+sx__6 = casadi__SX__CONSTRUCTOR__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__7" c_casadi__SX__CONSTRUCTOR__7
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__7
+  :: Sparsity -> IO SX
+casadi__SX__CONSTRUCTOR__7 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__7 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__7 :: Sparsity -> IO SX
+sx__7 = casadi__SX__CONSTRUCTOR__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__8" c_casadi__SX__CONSTRUCTOR__8
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__8
+  :: Int -> Int -> IO SX
+casadi__SX__CONSTRUCTOR__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__8 :: Int -> Int -> IO SX
+sx__8 = casadi__SX__CONSTRUCTOR__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__9" c_casadi__SX__CONSTRUCTOR__9
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__9
+  :: SX -> IO SX
+casadi__SX__CONSTRUCTOR__9 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__9 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx__9 :: SX -> IO SX
+sx__9 = casadi__SX__CONSTRUCTOR__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__10" c_casadi__SX__CONSTRUCTOR__10
+  :: Ptr (Ptr StdString) -> IO (Ptr SX')
+
+casadi__SX__CONSTRUCTOR__10
+  :: IO SX
+casadi__SX__CONSTRUCTOR__10  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__CONSTRUCTOR__10 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sx__10 :: IO SX
+sx__10 = casadi__SX__CONSTRUCTOR__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__T" c_casadi__SX__T
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__T
+  :: SX -> IO SX
+casadi__SX__T x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__T errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_T :: SXClass a => a -> IO SX
+sx_T x = casadi__SX__T (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX____nonzero__" c_casadi__SX____nonzero__
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX____nonzero__
+  :: SX -> IO Bool
+casadi__SX____nonzero__ x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX____nonzero__ errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx___nonzero__ :: SXClass a => a -> IO Bool
+sx___nonzero__ x = casadi__SX____nonzero__ (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__binary" c_casadi__SX__binary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__binary
+  :: Int -> SX -> SX -> IO SX
+casadi__SX__binary x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__binary errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_binary :: Int -> SX -> SX -> IO SX
+sx_binary = casadi__SX__binary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__clear" c_casadi__SX__clear
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+
+casadi__SX__clear
+  :: SX -> IO ()
+casadi__SX__clear x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__clear errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_clear :: SXClass a => a -> IO ()
+sx_clear x = casadi__SX__clear (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__colind" c_casadi__SX__colind
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
+
+casadi__SX__colind
+  :: SX -> Int -> IO Int
+casadi__SX__colind x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__colind errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_colind :: SXClass a => a -> Int -> IO Int
+sx_colind x = casadi__SX__colind (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__dep__0" c_casadi__SX__dep__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__dep__0
+  :: SX -> IO SX
+casadi__SX__dep__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__dep__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_dep__0 :: SXClass a => a -> IO SX
+sx_dep__0 x = casadi__SX__dep__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__dep__1" c_casadi__SX__dep__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi__SX__dep__1
+  :: SX -> Int -> IO SX
+casadi__SX__dep__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__dep__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_dep__1 :: SXClass a => a -> Int -> IO SX
+sx_dep__1 x = casadi__SX__dep__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__dim" c_casadi__SX__dim
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
+
+casadi__SX__dim
+  :: SX -> IO String
+casadi__SX__dim x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__dim errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_dim :: SXClass a => a -> IO String
+sx_dim x = casadi__SX__dim (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__element_hash" c_casadi__SX__element_hash
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CSize
+
+casadi__SX__element_hash
+  :: SX -> IO CSize
+casadi__SX__element_hash x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__element_hash errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_element_hash :: SXClass a => a -> IO CSize
+sx_element_hash x = casadi__SX__element_hash (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__enlarge__0" c_casadi__SX__enlarge__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__SX__enlarge__0
+  :: SX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+casadi__SX__enlarge__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_enlarge__0 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+sx_enlarge__0 x = casadi__SX__enlarge__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__enlarge__1" c_casadi__SX__enlarge__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__SX__enlarge__1
+  :: SX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__SX__enlarge__1 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_enlarge__1 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+sx_enlarge__1 x = casadi__SX__enlarge__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__erase__0" c_casadi__SX__erase__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO ()
+
+casadi__SX__erase__0
+  :: SX -> Vector Int -> IO ()
+casadi__SX__erase__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__erase__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_erase__0 :: SXClass a => a -> Vector Int -> IO ()
+sx_erase__0 x = casadi__SX__erase__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__erase__1" c_casadi__SX__erase__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__SX__erase__1
+  :: SX -> Vector Int -> Bool -> IO ()
+casadi__SX__erase__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__erase__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_erase__1 :: SXClass a => a -> Vector Int -> Bool -> IO ()
+sx_erase__1 x = casadi__SX__erase__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__erase__2" c_casadi__SX__erase__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__SX__erase__2
+  :: SX -> Vector Int -> Vector Int -> IO ()
+casadi__SX__erase__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__erase__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_erase__2 :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
+sx_erase__2 x = casadi__SX__erase__2 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__erase__3" c_casadi__SX__erase__3
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__SX__erase__3
+  :: SX -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__SX__erase__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__erase__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_erase__3 :: SXClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
+sx_erase__3 x = casadi__SX__erase__3 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__eye" c_casadi__SX__eye
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
+
+casadi__SX__eye
+  :: Int -> IO SX
+casadi__SX__eye x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__eye errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_eye :: Int -> IO SX
+sx_eye = casadi__SX__eye
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get__0" c_casadi__SX__get__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__SX__get__0
+  :: SX -> Bool -> IM -> IM -> IO (SX)
+casadi__SX__get__0 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get__0 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get__0/c_casadi__SX__get__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get__0 :: SXClass a => a -> Bool -> IM -> IM -> IO (SX)
+sx_get__0 x = casadi__SX__get__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get__1" c_casadi__SX__get__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__SX__get__1
+  :: SX -> Bool -> IM -> Slice -> IO (SX)
+casadi__SX__get__1 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get__1 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get__1/c_casadi__SX__get__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get__1 :: SXClass a => a -> Bool -> IM -> Slice -> IO (SX)
+sx_get__1 x = casadi__SX__get__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get__2" c_casadi__SX__get__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__SX__get__2
+  :: SX -> Bool -> Slice -> IM -> IO (SX)
+casadi__SX__get__2 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get__2 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get__2/c_casadi__SX__get__2" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get__2 :: SXClass a => a -> Bool -> Slice -> IM -> IO (SX)
+sx_get__2 x = casadi__SX__get__2 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get__3" c_casadi__SX__get__3
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__SX__get__3
+  :: SX -> Bool -> Slice -> Slice -> IO (SX)
+casadi__SX__get__3 x0 x2 x3 x4 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get__3 errStrPtrP x0' o1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get__3/c_casadi__SX__get__3" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get__3 :: SXClass a => a -> Bool -> Slice -> Slice -> IO (SX)
+sx_get__3 x = casadi__SX__get__3 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get__4" c_casadi__SX__get__4
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__SX__get__4
+  :: SX -> Bool -> Sparsity -> IO (SX)
+casadi__SX__get__4 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get__4 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get__4/c_casadi__SX__get__4" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get__4 :: SXClass a => a -> Bool -> Sparsity -> IO (SX)
+sx_get__4 x = casadi__SX__get__4 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get__5" c_casadi__SX__get__5
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr IM' -> IO ()
+
+casadi__SX__get__5
+  :: SX -> Bool -> IM -> IO (SX)
+casadi__SX__get__5 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get__5 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get__5/c_casadi__SX__get__5" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get__5 :: SXClass a => a -> Bool -> IM -> IO (SX)
+sx_get__5 x = casadi__SX__get__5 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get__6" c_casadi__SX__get__6
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__SX__get__6
+  :: SX -> Bool -> Slice -> IO (SX)
+casadi__SX__get__6 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get__6 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get__6/c_casadi__SX__get__6" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get__6 :: SXClass a => a -> Bool -> Slice -> IO (SX)
+sx_get__6 x = casadi__SX__get__6 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__getEqualityCheckingDepth" c_casadi__SX__getEqualityCheckingDepth
+  :: Ptr (Ptr StdString) -> IO CInt
+
+casadi__SX__getEqualityCheckingDepth
+  :: IO Int
+casadi__SX__getEqualityCheckingDepth  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__getEqualityCheckingDepth errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sx_getEqualityCheckingDepth :: IO Int
+sx_getEqualityCheckingDepth = casadi__SX__getEqualityCheckingDepth
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get_colind" c_casadi__SX__get_colind
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt))
+
+casadi__SX__get_colind
+  :: SX -> IO (Vector Int)
+casadi__SX__get_colind x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get_colind errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_get_colind :: SXClass a => a -> IO (Vector Int)
+sx_get_colind x = casadi__SX__get_colind (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get_input" c_casadi__SX__get_input
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi__SX__get_input
+  :: Function -> IO (Vector SX)
+casadi__SX__get_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_get_input :: Function -> IO (Vector SX)
+sx_get_input = casadi__SX__get_input
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get_nonzeros" c_casadi__SX__get_nonzeros
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SXElem')))
+
+casadi__SX__get_nonzeros
+  :: SX -> IO (Vector SXElem)
+casadi__SX__get_nonzeros x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get_nonzeros errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_get_nonzeros :: SXClass a => a -> IO (Vector SXElem)
+sx_get_nonzeros x = casadi__SX__get_nonzeros (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get_nz__0" c_casadi__SX__get_nz__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr IM' -> IO ()
+
+casadi__SX__get_nz__0
+  :: SX -> Bool -> IM -> IO (SX)
+casadi__SX__get_nz__0 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get_nz__0 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get_nz__0/c_casadi__SX__get_nz__0" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get_nz__0 :: SXClass a => a -> Bool -> IM -> IO (SX)
+sx_get_nz__0 x = casadi__SX__get_nz__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get_nz__1" c_casadi__SX__get_nz__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr SX') -> CInt -> Ptr Slice' -> IO ()
+
+casadi__SX__get_nz__1
+  :: SX -> Bool -> Slice -> IO (SX)
+casadi__SX__get_nz__1 x0 x2 x3 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get_nz__1 errStrPtrP x0' o1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__get_nz__1/c_casadi__SX__get_nz__1" else wrapReturn o1''
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return (o1''')
+
+
+
+-- classy wrapper
+sx_get_nz__1 :: SXClass a => a -> Bool -> Slice -> IO (SX)
+sx_get_nz__1 x = casadi__SX__get_nz__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get_row" c_casadi__SX__get_row
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt))
+
+casadi__SX__get_row
+  :: SX -> IO (Vector Int)
+casadi__SX__get_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_get_row :: SXClass a => a -> IO (Vector Int)
+sx_get_row x = casadi__SX__get_row (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__get_sparsity" c_casadi__SX__get_sparsity
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity')
+
+casadi__SX__get_sparsity
+  :: SX -> IO Sparsity
+casadi__SX__get_sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__get_sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_get_sparsity :: SXClass a => a -> IO Sparsity
+sx_get_sparsity x = casadi__SX__get_sparsity (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__grad__0" c_casadi__SX__grad__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__grad__0
+  :: Function -> String -> String -> IO SX
+casadi__SX__grad__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__grad__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_grad__0 :: Function -> String -> String -> IO SX
+sx_grad__0 = casadi__SX__grad__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__grad__1" c_casadi__SX__grad__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__grad__1
+  :: Function -> Int -> String -> IO SX
+casadi__SX__grad__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__grad__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_grad__1 :: Function -> Int -> String -> IO SX
+sx_grad__1 = casadi__SX__grad__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__grad__2" c_casadi__SX__grad__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__grad__2
+  :: Function -> String -> IO SX
+casadi__SX__grad__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__grad__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_grad__2 :: Function -> String -> IO SX
+sx_grad__2 = casadi__SX__grad__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__grad__3" c_casadi__SX__grad__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr SX')
+
+casadi__SX__grad__3
+  :: Function -> String -> Int -> IO SX
+casadi__SX__grad__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__grad__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_grad__3 :: Function -> String -> Int -> IO SX
+sx_grad__3 = casadi__SX__grad__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__grad__4" c_casadi__SX__grad__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SX')
+
+casadi__SX__grad__4
+  :: Function -> IO SX
+casadi__SX__grad__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__grad__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_grad__4 :: Function -> IO SX
+sx_grad__4 = casadi__SX__grad__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__grad__5" c_casadi__SX__grad__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr SX')
+
+casadi__SX__grad__5
+  :: Function -> Int -> IO SX
+casadi__SX__grad__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__grad__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_grad__5 :: Function -> Int -> IO SX
+sx_grad__5 = casadi__SX__grad__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__grad__6" c_casadi__SX__grad__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__grad__6
+  :: Function -> Int -> Int -> IO SX
+casadi__SX__grad__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__grad__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_grad__6 :: Function -> Int -> Int -> IO SX
+sx_grad__6 = casadi__SX__grad__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__has_duplicates" c_casadi__SX__has_duplicates
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__has_duplicates
+  :: SX -> IO Bool
+casadi__SX__has_duplicates x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__has_duplicates errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_has_duplicates :: SXClass a => a -> IO Bool
+sx_has_duplicates x = casadi__SX__has_duplicates (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__has_nz" c_casadi__SX__has_nz
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO CInt
+
+casadi__SX__has_nz
+  :: SX -> Int -> Int -> IO Bool
+casadi__SX__has_nz x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__has_nz errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_has_nz :: SXClass a => a -> Int -> Int -> IO Bool
+sx_has_nz x = casadi__SX__has_nz (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__has_zeros" c_casadi__SX__has_zeros
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__has_zeros
+  :: SX -> IO Bool
+casadi__SX__has_zeros x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__has_zeros errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_has_zeros :: SXClass a => a -> IO Bool
+sx_has_zeros x = casadi__SX__has_zeros (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__hess__0" c_casadi__SX__hess__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__hess__0
+  :: Function -> String -> String -> IO SX
+casadi__SX__hess__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__hess__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_hess__0 :: Function -> String -> String -> IO SX
+sx_hess__0 = casadi__SX__hess__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__hess__1" c_casadi__SX__hess__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__hess__1
+  :: Function -> Int -> String -> IO SX
+casadi__SX__hess__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__hess__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_hess__1 :: Function -> Int -> String -> IO SX
+sx_hess__1 = casadi__SX__hess__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__hess__2" c_casadi__SX__hess__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__hess__2
+  :: Function -> String -> IO SX
+casadi__SX__hess__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__hess__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_hess__2 :: Function -> String -> IO SX
+sx_hess__2 = casadi__SX__hess__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__hess__3" c_casadi__SX__hess__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr SX')
+
+casadi__SX__hess__3
+  :: Function -> String -> Int -> IO SX
+casadi__SX__hess__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__hess__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_hess__3 :: Function -> String -> Int -> IO SX
+sx_hess__3 = casadi__SX__hess__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__hess__4" c_casadi__SX__hess__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SX')
+
+casadi__SX__hess__4
+  :: Function -> IO SX
+casadi__SX__hess__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__hess__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_hess__4 :: Function -> IO SX
+sx_hess__4 = casadi__SX__hess__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__hess__5" c_casadi__SX__hess__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr SX')
+
+casadi__SX__hess__5
+  :: Function -> Int -> IO SX
+casadi__SX__hess__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__hess__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_hess__5 :: Function -> Int -> IO SX
+sx_hess__5 = casadi__SX__hess__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__hess__6" c_casadi__SX__hess__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__hess__6
+  :: Function -> Int -> Int -> IO SX
+casadi__SX__hess__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__hess__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_hess__6 :: Function -> Int -> Int -> IO SX
+sx_hess__6 = casadi__SX__hess__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__inf__0" c_casadi__SX__inf__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi__SX__inf__0
+  :: (Int, Int) -> IO SX
+casadi__SX__inf__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__inf__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_inf__0 :: (Int, Int) -> IO SX
+sx_inf__0 = casadi__SX__inf__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__inf__1" c_casadi__SX__inf__1
+  :: Ptr (Ptr StdString) -> IO (Ptr SX')
+
+casadi__SX__inf__1
+  :: IO SX
+casadi__SX__inf__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__inf__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sx_inf__1 :: IO SX
+sx_inf__1 = casadi__SX__inf__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__inf__2" c_casadi__SX__inf__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
+
+casadi__SX__inf__2
+  :: Int -> IO SX
+casadi__SX__inf__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__inf__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_inf__2 :: Int -> IO SX
+sx_inf__2 = casadi__SX__inf__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__inf__3" c_casadi__SX__inf__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__inf__3
+  :: Int -> Int -> IO SX
+casadi__SX__inf__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__inf__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_inf__3 :: Int -> Int -> IO SX
+sx_inf__3 = casadi__SX__inf__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__inf__4" c_casadi__SX__inf__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi__SX__inf__4
+  :: Sparsity -> IO SX
+casadi__SX__inf__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__inf__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_inf__4 :: Sparsity -> IO SX
+sx_inf__4 = casadi__SX__inf__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_column" c_casadi__SX__is_column
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_column
+  :: SX -> IO Bool
+casadi__SX__is_column x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_column errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_column :: SXClass a => a -> IO Bool
+sx_is_column x = casadi__SX__is_column (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_commutative" c_casadi__SX__is_commutative
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_commutative
+  :: SX -> IO Bool
+casadi__SX__is_commutative x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_commutative errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_commutative :: SXClass a => a -> IO Bool
+sx_is_commutative x = casadi__SX__is_commutative (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_constant" c_casadi__SX__is_constant
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_constant
+  :: SX -> IO Bool
+casadi__SX__is_constant x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_constant errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_constant :: SXClass a => a -> IO Bool
+sx_is_constant x = casadi__SX__is_constant (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_dense" c_casadi__SX__is_dense
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_dense
+  :: SX -> IO Bool
+casadi__SX__is_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_dense :: SXClass a => a -> IO Bool
+sx_is_dense x = casadi__SX__is_dense (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_empty__0" c_casadi__SX__is_empty__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_empty__0
+  :: SX -> IO Bool
+casadi__SX__is_empty__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_empty__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_empty__0 :: SXClass a => a -> IO Bool
+sx_is_empty__0 x = casadi__SX__is_empty__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_empty__1" c_casadi__SX__is_empty__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
+
+casadi__SX__is_empty__1
+  :: SX -> Bool -> IO Bool
+casadi__SX__is_empty__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_empty__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_empty__1 :: SXClass a => a -> Bool -> IO Bool
+sx_is_empty__1 x = casadi__SX__is_empty__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_identity" c_casadi__SX__is_identity
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_identity
+  :: SX -> IO Bool
+casadi__SX__is_identity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_identity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_identity :: SXClass a => a -> IO Bool
+sx_is_identity x = casadi__SX__is_identity (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_integer" c_casadi__SX__is_integer
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_integer
+  :: SX -> IO Bool
+casadi__SX__is_integer x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_integer errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_integer :: SXClass a => a -> IO Bool
+sx_is_integer x = casadi__SX__is_integer (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_leaf" c_casadi__SX__is_leaf
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_leaf
+  :: SX -> IO Bool
+casadi__SX__is_leaf x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_leaf errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_leaf :: SXClass a => a -> IO Bool
+sx_is_leaf x = casadi__SX__is_leaf (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_minus_one" c_casadi__SX__is_minus_one
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_minus_one
+  :: SX -> IO Bool
+casadi__SX__is_minus_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_minus_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_minus_one :: SXClass a => a -> IO Bool
+sx_is_minus_one x = casadi__SX__is_minus_one (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_one" c_casadi__SX__is_one
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_one
+  :: SX -> IO Bool
+casadi__SX__is_one x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_one errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_one :: SXClass a => a -> IO Bool
+sx_is_one x = casadi__SX__is_one (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_regular" c_casadi__SX__is_regular
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_regular
+  :: SX -> IO Bool
+casadi__SX__is_regular x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_regular errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_regular :: SXClass a => a -> IO Bool
+sx_is_regular x = casadi__SX__is_regular (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_row" c_casadi__SX__is_row
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_row
+  :: SX -> IO Bool
+casadi__SX__is_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_row :: SXClass a => a -> IO Bool
+sx_is_row x = casadi__SX__is_row (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_scalar__0" c_casadi__SX__is_scalar__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_scalar__0
+  :: SX -> IO Bool
+casadi__SX__is_scalar__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_scalar__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_scalar__0 :: SXClass a => a -> IO Bool
+sx_is_scalar__0 x = casadi__SX__is_scalar__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_scalar__1" c_casadi__SX__is_scalar__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
+
+casadi__SX__is_scalar__1
+  :: SX -> Bool -> IO Bool
+casadi__SX__is_scalar__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_scalar__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_scalar__1 :: SXClass a => a -> Bool -> IO Bool
+sx_is_scalar__1 x = casadi__SX__is_scalar__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_smooth" c_casadi__SX__is_smooth
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_smooth
+  :: SX -> IO Bool
+casadi__SX__is_smooth x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_smooth errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_smooth :: SXClass a => a -> IO Bool
+sx_is_smooth x = casadi__SX__is_smooth (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_square" c_casadi__SX__is_square
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_square
+  :: SX -> IO Bool
+casadi__SX__is_square x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_square errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_square :: SXClass a => a -> IO Bool
+sx_is_square x = casadi__SX__is_square (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_symbolic" c_casadi__SX__is_symbolic
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_symbolic
+  :: SX -> IO Bool
+casadi__SX__is_symbolic x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_symbolic errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_symbolic :: SXClass a => a -> IO Bool
+sx_is_symbolic x = casadi__SX__is_symbolic (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_tril" c_casadi__SX__is_tril
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_tril
+  :: SX -> IO Bool
+casadi__SX__is_tril x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_tril errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_tril :: SXClass a => a -> IO Bool
+sx_is_tril x = casadi__SX__is_tril (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_triu" c_casadi__SX__is_triu
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_triu
+  :: SX -> IO Bool
+casadi__SX__is_triu x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_triu errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_triu :: SXClass a => a -> IO Bool
+sx_is_triu x = casadi__SX__is_triu (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_valid_input" c_casadi__SX__is_valid_input
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_valid_input
+  :: SX -> IO Bool
+casadi__SX__is_valid_input x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_valid_input errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_valid_input :: SXClass a => a -> IO Bool
+sx_is_valid_input x = casadi__SX__is_valid_input (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_vector" c_casadi__SX__is_vector
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_vector
+  :: SX -> IO Bool
+casadi__SX__is_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_vector :: SXClass a => a -> IO Bool
+sx_is_vector x = casadi__SX__is_vector (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__is_zero" c_casadi__SX__is_zero
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__is_zero
+  :: SX -> IO Bool
+casadi__SX__is_zero x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__is_zero errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_is_zero :: SXClass a => a -> IO Bool
+sx_is_zero x = casadi__SX__is_zero (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__0" c_casadi__SX__jac__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__jac__0
+  :: Function -> String -> String -> IO SX
+casadi__SX__jac__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__0 :: Function -> String -> String -> IO SX
+sx_jac__0 = casadi__SX__jac__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__1" c_casadi__SX__jac__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__1
+  :: Function -> String -> String -> Bool -> IO SX
+casadi__SX__jac__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__1 :: Function -> String -> String -> Bool -> IO SX
+sx_jac__1 = casadi__SX__jac__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__2" c_casadi__SX__jac__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__2
+  :: Function -> String -> String -> Bool -> Bool -> IO SX
+casadi__SX__jac__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__2 :: Function -> String -> String -> Bool -> Bool -> IO SX
+sx_jac__2 = casadi__SX__jac__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__3" c_casadi__SX__jac__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__jac__3
+  :: Function -> Int -> String -> IO SX
+casadi__SX__jac__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__3 :: Function -> Int -> String -> IO SX
+sx_jac__3 = casadi__SX__jac__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__4" c_casadi__SX__jac__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__4
+  :: Function -> Int -> String -> Bool -> IO SX
+casadi__SX__jac__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__4 :: Function -> Int -> String -> Bool -> IO SX
+sx_jac__4 = casadi__SX__jac__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__5" c_casadi__SX__jac__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__5
+  :: Function -> Int -> String -> Bool -> Bool -> IO SX
+casadi__SX__jac__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__5 :: Function -> Int -> String -> Bool -> Bool -> IO SX
+sx_jac__5 = casadi__SX__jac__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__6" c_casadi__SX__jac__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__jac__6
+  :: Function -> String -> IO SX
+casadi__SX__jac__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__6 :: Function -> String -> IO SX
+sx_jac__6 = casadi__SX__jac__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__7" c_casadi__SX__jac__7
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__7
+  :: Function -> String -> Int -> IO SX
+casadi__SX__jac__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__7 :: Function -> String -> Int -> IO SX
+sx_jac__7 = casadi__SX__jac__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__8" c_casadi__SX__jac__8
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__8
+  :: Function -> String -> Int -> Bool -> IO SX
+casadi__SX__jac__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__8 :: Function -> String -> Int -> Bool -> IO SX
+sx_jac__8 = casadi__SX__jac__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__9" c_casadi__SX__jac__9
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__9
+  :: Function -> String -> Int -> Bool -> Bool -> IO SX
+casadi__SX__jac__9 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__9 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__9 :: Function -> String -> Int -> Bool -> Bool -> IO SX
+sx_jac__9 = casadi__SX__jac__9
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__10" c_casadi__SX__jac__10
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SX')
+
+casadi__SX__jac__10
+  :: Function -> IO SX
+casadi__SX__jac__10 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__10 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__10 :: Function -> IO SX
+sx_jac__10 = casadi__SX__jac__10
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__11" c_casadi__SX__jac__11
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__11
+  :: Function -> Int -> IO SX
+casadi__SX__jac__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__11 :: Function -> Int -> IO SX
+sx_jac__11 = casadi__SX__jac__11
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__12" c_casadi__SX__jac__12
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__12
+  :: Function -> Int -> Int -> IO SX
+casadi__SX__jac__12 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__12 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__12 :: Function -> Int -> Int -> IO SX
+sx_jac__12 = casadi__SX__jac__12
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__13" c_casadi__SX__jac__13
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__13
+  :: Function -> Int -> Int -> Bool -> IO SX
+casadi__SX__jac__13 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__13 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__13 :: Function -> Int -> Int -> Bool -> IO SX
+sx_jac__13 = casadi__SX__jac__13
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__jac__14" c_casadi__SX__jac__14
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__jac__14
+  :: Function -> Int -> Int -> Bool -> Bool -> IO SX
+casadi__SX__jac__14 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__jac__14 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_jac__14 :: Function -> Int -> Int -> Bool -> Bool -> IO SX
+sx_jac__14 = casadi__SX__jac__14
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__matrix_matrix" c_casadi__SX__matrix_matrix
+  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__matrix_matrix
+  :: Int -> SX -> SX -> IO SX
+casadi__SX__matrix_matrix x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__matrix_matrix errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_matrix_matrix :: Int -> SX -> SX -> IO SX
+sx_matrix_matrix = casadi__SX__matrix_matrix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__matrix_scalar" c_casadi__SX__matrix_scalar
+  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__matrix_scalar
+  :: Int -> SX -> SX -> IO SX
+casadi__SX__matrix_scalar x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__matrix_scalar errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_matrix_scalar :: Int -> SX -> SX -> IO SX
+sx_matrix_scalar = casadi__SX__matrix_scalar
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__n_dep" c_casadi__SX__n_dep
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__n_dep
+  :: SX -> IO Int
+casadi__SX__n_dep x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__n_dep errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_n_dep :: SXClass a => a -> IO Int
+sx_n_dep x = casadi__SX__n_dep (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__name" c_casadi__SX__name
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
+
+casadi__SX__name
+  :: SX -> IO String
+casadi__SX__name x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_name :: SXClass a => a -> IO String
+sx_name x = casadi__SX__name (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nan__0" c_casadi__SX__nan__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi__SX__nan__0
+  :: (Int, Int) -> IO SX
+casadi__SX__nan__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nan__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nan__0 :: (Int, Int) -> IO SX
+sx_nan__0 = casadi__SX__nan__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nan__1" c_casadi__SX__nan__1
+  :: Ptr (Ptr StdString) -> IO (Ptr SX')
+
+casadi__SX__nan__1
+  :: IO SX
+casadi__SX__nan__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nan__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nan__1 :: IO SX
+sx_nan__1 = casadi__SX__nan__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nan__2" c_casadi__SX__nan__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
+
+casadi__SX__nan__2
+  :: Int -> IO SX
+casadi__SX__nan__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nan__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nan__2 :: Int -> IO SX
+sx_nan__2 = casadi__SX__nan__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nan__3" c_casadi__SX__nan__3
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__nan__3
+  :: Int -> Int -> IO SX
+casadi__SX__nan__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nan__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nan__3 :: Int -> Int -> IO SX
+sx_nan__3 = casadi__SX__nan__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nan__4" c_casadi__SX__nan__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi__SX__nan__4
+  :: Sparsity -> IO SX
+casadi__SX__nan__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nan__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nan__4 :: Sparsity -> IO SX
+sx_nan__4 = casadi__SX__nan__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nnz" c_casadi__SX__nnz
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__nnz
+  :: SX -> IO Int
+casadi__SX__nnz x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nnz errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nnz :: SXClass a => a -> IO Int
+sx_nnz x = casadi__SX__nnz (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nnz_diag" c_casadi__SX__nnz_diag
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__nnz_diag
+  :: SX -> IO Int
+casadi__SX__nnz_diag x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nnz_diag errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nnz_diag :: SXClass a => a -> IO Int
+sx_nnz_diag x = casadi__SX__nnz_diag (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nnz_lower" c_casadi__SX__nnz_lower
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__nnz_lower
+  :: SX -> IO Int
+casadi__SX__nnz_lower x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nnz_lower errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nnz_lower :: SXClass a => a -> IO Int
+sx_nnz_lower x = casadi__SX__nnz_lower (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__nnz_upper" c_casadi__SX__nnz_upper
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__nnz_upper
+  :: SX -> IO Int
+casadi__SX__nnz_upper x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__nnz_upper errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_nnz_upper :: SXClass a => a -> IO Int
+sx_nnz_upper x = casadi__SX__nnz_upper (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__numel__0" c_casadi__SX__numel__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
+
+casadi__SX__numel__0
+  :: SX -> Int -> IO Int
+casadi__SX__numel__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__numel__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_numel__0 :: SXClass a => a -> Int -> IO Int
+sx_numel__0 x = casadi__SX__numel__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__numel__1" c_casadi__SX__numel__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__numel__1
+  :: SX -> IO Int
+casadi__SX__numel__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__numel__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_numel__1 :: SXClass a => a -> IO Int
+sx_numel__1 x = casadi__SX__numel__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__ones__0" c_casadi__SX__ones__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi__SX__ones__0
+  :: (Int, Int) -> IO SX
+casadi__SX__ones__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__ones__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_ones__0 :: (Int, Int) -> IO SX
+sx_ones__0 = casadi__SX__ones__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__ones__1" c_casadi__SX__ones__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi__SX__ones__1
+  :: Sparsity -> IO SX
+casadi__SX__ones__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__ones__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_ones__1 :: Sparsity -> IO SX
+sx_ones__1 = casadi__SX__ones__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__ones__2" c_casadi__SX__ones__2
+  :: Ptr (Ptr StdString) -> IO (Ptr SX')
+
+casadi__SX__ones__2
+  :: IO SX
+casadi__SX__ones__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__ones__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sx_ones__2 :: IO SX
+sx_ones__2 = casadi__SX__ones__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__ones__3" c_casadi__SX__ones__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
+
+casadi__SX__ones__3
+  :: Int -> IO SX
+casadi__SX__ones__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__ones__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_ones__3 :: Int -> IO SX
+sx_ones__3 = casadi__SX__ones__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__ones__4" c_casadi__SX__ones__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__ones__4
+  :: Int -> Int -> IO SX
+casadi__SX__ones__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__ones__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_ones__4 :: Int -> Int -> IO SX
+sx_ones__4 = casadi__SX__ones__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__operator__plus" c_casadi__SX__operator__plus
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__operator__plus
+  :: SX -> IO SX
+casadi__SX__operator__plus x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__operator__plus errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_operator__plus :: SXClass a => a -> IO SX
+sx_operator__plus x = casadi__SX__operator__plus (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__operator__minus" c_casadi__SX__operator__minus
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__operator__minus
+  :: SX -> IO SX
+casadi__SX__operator__minus x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__operator__minus errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_operator__minus :: SXClass a => a -> IO SX
+sx_operator__minus x = casadi__SX__operator__minus (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__operator_double" c_casadi__SX__operator_double
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CDouble
+
+casadi__SX__operator_double
+  :: SX -> IO Double
+casadi__SX__operator_double x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__operator_double errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_operator_double :: SXClass a => a -> IO Double
+sx_operator_double x = casadi__SX__operator_double (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__operator_int" c_casadi__SX__operator_int
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__operator_int
+  :: SX -> IO Int
+casadi__SX__operator_int x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__operator_int errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_operator_int :: SXClass a => a -> IO Int
+sx_operator_int x = casadi__SX__operator_int (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__print_dense" c_casadi__SX__print_dense
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+
+casadi__SX__print_dense
+  :: SX -> IO ()
+casadi__SX__print_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__print_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_print_dense :: SXClass a => a -> IO ()
+sx_print_dense x = casadi__SX__print_dense (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__print_scalar" c_casadi__SX__print_scalar
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+
+casadi__SX__print_scalar
+  :: SX -> IO ()
+casadi__SX__print_scalar x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__print_scalar errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_print_scalar :: SXClass a => a -> IO ()
+sx_print_scalar x = casadi__SX__print_scalar (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__print_sparse" c_casadi__SX__print_sparse
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+
+casadi__SX__print_sparse
+  :: SX -> IO ()
+casadi__SX__print_sparse x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__print_sparse errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_print_sparse :: SXClass a => a -> IO ()
+sx_print_sparse x = casadi__SX__print_sparse (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__print_split" c_casadi__SX__print_split
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (Ptr (StdVec (Ptr StdString))) -> Ptr (Ptr (StdVec (Ptr StdString))) -> IO ()
+
+casadi__SX__print_split
+  :: SX -> IO (Vector String, Vector String)
+casadi__SX__print_split x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__print_split errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__SX__print_split/c_casadi__SX__print_split" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__SX__print_split/c_casadi__SX__print_split" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+-- classy wrapper
+sx_print_split :: SXClass a => a -> IO (Vector String, Vector String)
+sx_print_split x = casadi__SX__print_split (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__print_vector" c_casadi__SX__print_vector
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+
+casadi__SX__print_vector
+  :: SX -> IO ()
+casadi__SX__print_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__print_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_print_vector :: SXClass a => a -> IO ()
+sx_print_vector x = casadi__SX__print_vector (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__printme" c_casadi__SX__printme
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__printme
+  :: SX -> SX -> IO SX
+casadi__SX__printme x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__printme errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_printme :: SXClass a => a -> SX -> IO SX
+sx_printme x = casadi__SX__printme (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__remove" c_casadi__SX__remove
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__SX__remove
+  :: SX -> Vector Int -> Vector Int -> IO ()
+casadi__SX__remove x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__remove errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_remove :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
+sx_remove x = casadi__SX__remove (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__reserve__0" c_casadi__SX__reserve__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO ()
+
+casadi__SX__reserve__0
+  :: SX -> Int -> Int -> IO ()
+casadi__SX__reserve__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__reserve__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_reserve__0 :: SXClass a => a -> Int -> Int -> IO ()
+sx_reserve__0 x = casadi__SX__reserve__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__reserve__1" c_casadi__SX__reserve__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO ()
+
+casadi__SX__reserve__1
+  :: SX -> Int -> IO ()
+casadi__SX__reserve__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__reserve__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_reserve__1 :: SXClass a => a -> Int -> IO ()
+sx_reserve__1 x = casadi__SX__reserve__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__resetInput" c_casadi__SX__resetInput
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+
+casadi__SX__resetInput
+  :: SX -> IO ()
+casadi__SX__resetInput x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__resetInput errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_resetInput :: SXClass a => a -> IO ()
+sx_resetInput x = casadi__SX__resetInput (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__resize" c_casadi__SX__resize
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO ()
+
+casadi__SX__resize
+  :: SX -> Int -> Int -> IO ()
+casadi__SX__resize x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__resize errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_resize :: SXClass a => a -> Int -> Int -> IO ()
+sx_resize x = casadi__SX__resize (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__row" c_casadi__SX__row
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
+
+casadi__SX__row
+  :: SX -> Int -> IO Int
+casadi__SX__row x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__row errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_row :: SXClass a => a -> Int -> IO Int
+sx_row x = casadi__SX__row (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sanity_check__0" c_casadi__SX__sanity_check__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+
+casadi__SX__sanity_check__0
+  :: SX -> IO ()
+casadi__SX__sanity_check__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sanity_check__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_sanity_check__0 :: SXClass a => a -> IO ()
+sx_sanity_check__0 x = casadi__SX__sanity_check__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sanity_check__1" c_casadi__SX__sanity_check__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO ()
+
+casadi__SX__sanity_check__1
+  :: SX -> Bool -> IO ()
+casadi__SX__sanity_check__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sanity_check__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_sanity_check__1 :: SXClass a => a -> Bool -> IO ()
+sx_sanity_check__1 x = casadi__SX__sanity_check__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__scalar_matrix" c_casadi__SX__scalar_matrix
+  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__scalar_matrix
+  :: Int -> SX -> SX -> IO SX
+casadi__SX__scalar_matrix x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__scalar_matrix errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_scalar_matrix :: Int -> SX -> SX -> IO SX
+sx_scalar_matrix = casadi__SX__scalar_matrix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set__0" c_casadi__SX__set__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi__SX__set__0
+  :: SX -> SX -> Bool -> IM -> IM -> IO ()
+casadi__SX__set__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set__0 :: SXClass a => a -> SX -> Bool -> IM -> IM -> IO ()
+sx_set__0 x = casadi__SX__set__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set__1" c_casadi__SX__set__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IM' -> Ptr Slice' -> IO ()
+
+casadi__SX__set__1
+  :: SX -> SX -> Bool -> IM -> Slice -> IO ()
+casadi__SX__set__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set__1 :: SXClass a => a -> SX -> Bool -> IM -> Slice -> IO ()
+sx_set__1 x = casadi__SX__set__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set__2" c_casadi__SX__set__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr IM' -> IO ()
+
+casadi__SX__set__2
+  :: SX -> SX -> Bool -> Slice -> IM -> IO ()
+casadi__SX__set__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set__2 :: SXClass a => a -> SX -> Bool -> Slice -> IM -> IO ()
+sx_set__2 x = casadi__SX__set__2 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set__3" c_casadi__SX__set__3
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO ()
+
+casadi__SX__set__3
+  :: SX -> SX -> Bool -> Slice -> Slice -> IO ()
+casadi__SX__set__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set__3 :: SXClass a => a -> SX -> Bool -> Slice -> Slice -> IO ()
+sx_set__3 x = casadi__SX__set__3 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set__4" c_casadi__SX__set__4
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Sparsity' -> IO ()
+
+casadi__SX__set__4
+  :: SX -> SX -> Bool -> Sparsity -> IO ()
+casadi__SX__set__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set__4 :: SXClass a => a -> SX -> Bool -> Sparsity -> IO ()
+sx_set__4 x = casadi__SX__set__4 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set__5" c_casadi__SX__set__5
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IM' -> IO ()
+
+casadi__SX__set__5
+  :: SX -> SX -> Bool -> IM -> IO ()
+casadi__SX__set__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set__5 :: SXClass a => a -> SX -> Bool -> IM -> IO ()
+sx_set__5 x = casadi__SX__set__5 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set__6" c_casadi__SX__set__6
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__SX__set__6
+  :: SX -> SX -> Bool -> Slice -> IO ()
+casadi__SX__set__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set__6 :: SXClass a => a -> SX -> Bool -> Slice -> IO ()
+sx_set__6 x = casadi__SX__set__6 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__0" c_casadi__SX__setEqualityCheckingDepth__0
+  :: Ptr (Ptr StdString) -> IO ()
+
+casadi__SX__setEqualityCheckingDepth__0
+  :: IO ()
+casadi__SX__setEqualityCheckingDepth__0  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__setEqualityCheckingDepth__0 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ()
+
+
+
+-- classy wrapper
+sx_setEqualityCheckingDepth__0 :: IO ()
+sx_setEqualityCheckingDepth__0 = casadi__SX__setEqualityCheckingDepth__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__1" c_casadi__SX__setEqualityCheckingDepth__1
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__SX__setEqualityCheckingDepth__1
+  :: Int -> IO ()
+casadi__SX__setEqualityCheckingDepth__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__setEqualityCheckingDepth__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_setEqualityCheckingDepth__1 :: Int -> IO ()
+sx_setEqualityCheckingDepth__1 = casadi__SX__setEqualityCheckingDepth__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__setPrecision" c_casadi__SX__setPrecision
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__SX__setPrecision
+  :: Int -> IO ()
+casadi__SX__setPrecision x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__setPrecision errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_setPrecision :: Int -> IO ()
+sx_setPrecision = casadi__SX__setPrecision
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__setScientific" c_casadi__SX__setScientific
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__SX__setScientific
+  :: Bool -> IO ()
+casadi__SX__setScientific x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__setScientific errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_setScientific :: Bool -> IO ()
+sx_setScientific = casadi__SX__setScientific
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__setWidth" c_casadi__SX__setWidth
+  :: Ptr (Ptr StdString) -> CInt -> IO ()
+
+casadi__SX__setWidth
+  :: Int -> IO ()
+casadi__SX__setWidth x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__setWidth errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_setWidth :: Int -> IO ()
+sx_setWidth = casadi__SX__setWidth
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set_nz__0" c_casadi__SX__set_nz__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IM' -> IO ()
+
+casadi__SX__set_nz__0
+  :: SX -> SX -> Bool -> IM -> IO ()
+casadi__SX__set_nz__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set_nz__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set_nz__0 :: SXClass a => a -> SX -> Bool -> IM -> IO ()
+sx_set_nz__0 x = casadi__SX__set_nz__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__set_nz__1" c_casadi__SX__set_nz__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO ()
+
+casadi__SX__set_nz__1
+  :: SX -> SX -> Bool -> Slice -> IO ()
+casadi__SX__set_nz__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__set_nz__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sx_set_nz__1 :: SXClass a => a -> SX -> Bool -> Slice -> IO ()
+sx_set_nz__1 x = casadi__SX__set_nz__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__size__0" c_casadi__SX__size__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt
+
+casadi__SX__size__0
+  :: SX -> Int -> IO Int
+casadi__SX__size__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__size__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_size__0 :: SXClass a => a -> Int -> IO Int
+sx_size__0 x = casadi__SX__size__0 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__size__1" c_casadi__SX__size__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdPair CInt CInt))
+
+casadi__SX__size__1
+  :: SX -> IO (Int, Int)
+casadi__SX__size__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__size__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_size__1 :: SXClass a => a -> IO (Int, Int)
+sx_size__1 x = casadi__SX__size__1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__size1" c_casadi__SX__size1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__size1
+  :: SX -> IO Int
+casadi__SX__size1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__size1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_size1 :: SXClass a => a -> IO Int
+sx_size1 x = casadi__SX__size1 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__size2" c_casadi__SX__size2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi__SX__size2
+  :: SX -> IO Int
+casadi__SX__size2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__size2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_size2 :: SXClass a => a -> IO Int
+sx_size2 x = casadi__SX__size2 (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sparsity" c_casadi__SX__sparsity
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity')
+
+casadi__SX__sparsity
+  :: SX -> IO Sparsity
+casadi__SX__sparsity x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sparsity errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sparsity :: SXClass a => a -> IO Sparsity
+sx_sparsity x = casadi__SX__sparsity (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__0" c_casadi__SX__sym__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+
+casadi__SX__sym__0
+  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX))
+casadi__SX__sym__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX))
+sx_sym__0 = casadi__SX__sym__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__1" c_casadi__SX__sym__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+
+casadi__SX__sym__1
+  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX))
+casadi__SX__sym__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX))
+sx_sym__1 = casadi__SX__sym__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__2" c_casadi__SX__sym__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi__SX__sym__2
+  :: String -> Int -> Int -> Int -> IO (Vector SX)
+casadi__SX__sym__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector SX)
+sx_sym__2 = casadi__SX__sym__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__3" c_casadi__SX__sym__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi__SX__sym__3
+  :: String -> Sparsity -> Int -> IO (Vector SX)
+casadi__SX__sym__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__3 :: String -> Sparsity -> Int -> IO (Vector SX)
+sx_sym__3 = casadi__SX__sym__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__4" c_casadi__SX__sym__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi__SX__sym__4
+  :: String -> Sparsity -> IO SX
+casadi__SX__sym__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__4 :: String -> Sparsity -> IO SX
+sx_sym__4 = casadi__SX__sym__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__5" c_casadi__SX__sym__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi__SX__sym__5
+  :: String -> (Int, Int) -> IO SX
+casadi__SX__sym__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__5 :: String -> (Int, Int) -> IO SX
+sx_sym__5 = casadi__SX__sym__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__6" c_casadi__SX__sym__6
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__sym__6
+  :: String -> IO SX
+casadi__SX__sym__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__6 :: String -> IO SX
+sx_sym__6 = casadi__SX__sym__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__7" c_casadi__SX__sym__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr SX')
+
+casadi__SX__sym__7
+  :: String -> Int -> IO SX
+casadi__SX__sym__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__7 :: String -> Int -> IO SX
+sx_sym__7 = casadi__SX__sym__7
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__sym__8" c_casadi__SX__sym__8
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__sym__8
+  :: String -> Int -> Int -> IO SX
+casadi__SX__sym__8 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__sym__8 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_sym__8 :: String -> Int -> Int -> IO SX
+sx_sym__8 = casadi__SX__sym__8
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__tang__0" c_casadi__SX__tang__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__tang__0
+  :: Function -> String -> String -> IO SX
+casadi__SX__tang__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__tang__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_tang__0 :: Function -> String -> String -> IO SX
+sx_tang__0 = casadi__SX__tang__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__tang__1" c_casadi__SX__tang__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__tang__1
+  :: Function -> Int -> String -> IO SX
+casadi__SX__tang__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__tang__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_tang__1 :: Function -> Int -> String -> IO SX
+sx_tang__1 = casadi__SX__tang__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__tang__2" c_casadi__SX__tang__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr SX')
+
+casadi__SX__tang__2
+  :: Function -> String -> IO SX
+casadi__SX__tang__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__tang__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_tang__2 :: Function -> String -> IO SX
+sx_tang__2 = casadi__SX__tang__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__tang__3" c_casadi__SX__tang__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr SX')
+
+casadi__SX__tang__3
+  :: Function -> String -> Int -> IO SX
+casadi__SX__tang__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__tang__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_tang__3 :: Function -> String -> Int -> IO SX
+sx_tang__3 = casadi__SX__tang__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__tang__4" c_casadi__SX__tang__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SX')
+
+casadi__SX__tang__4
+  :: Function -> IO SX
+casadi__SX__tang__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__tang__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_tang__4 :: Function -> IO SX
+sx_tang__4 = casadi__SX__tang__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__tang__5" c_casadi__SX__tang__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr SX')
+
+casadi__SX__tang__5
+  :: Function -> Int -> IO SX
+casadi__SX__tang__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__tang__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_tang__5 :: Function -> Int -> IO SX
+sx_tang__5 = casadi__SX__tang__5
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__tang__6" c_casadi__SX__tang__6
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__tang__6
+  :: Function -> Int -> Int -> IO SX
+casadi__SX__tang__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__tang__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_tang__6 :: Function -> Int -> Int -> IO SX
+sx_tang__6 = casadi__SX__tang__6
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__triplet__0" c_casadi__SX__triplet__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi__SX__triplet__0
+  :: Vector Int -> Vector Int -> SX -> (Int, Int) -> IO SX
+casadi__SX__triplet__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__triplet__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_triplet__0 :: Vector Int -> Vector Int -> SX -> (Int, Int) -> IO SX
+sx_triplet__0 = casadi__SX__triplet__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__triplet__1" c_casadi__SX__triplet__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__triplet__1
+  :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX
+casadi__SX__triplet__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_triplet__1 :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX
+sx_triplet__1 = casadi__SX__triplet__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__triplet__2" c_casadi__SX__triplet__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__triplet__2
+  :: Vector Int -> Vector Int -> SX -> IO SX
+casadi__SX__triplet__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__triplet__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_triplet__2 :: Vector Int -> Vector Int -> SX -> IO SX
+sx_triplet__2 = casadi__SX__triplet__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__type_name" c_casadi__SX__type_name
+  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+
+casadi__SX__type_name
+  :: IO String
+casadi__SX__type_name  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__type_name errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sx_type_name :: IO String
+sx_type_name = casadi__SX__type_name
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__unary" c_casadi__SX__unary
+  :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> IO (Ptr SX')
+
+casadi__SX__unary
+  :: Int -> SX -> IO SX
+casadi__SX__unary x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__unary errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_unary :: Int -> SX -> IO SX
+sx_unary = casadi__SX__unary
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__zeros__0" c_casadi__SX__zeros__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi__SX__zeros__0
+  :: (Int, Int) -> IO SX
+casadi__SX__zeros__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__zeros__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_zeros__0 :: (Int, Int) -> IO SX
+sx_zeros__0 = casadi__SX__zeros__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__zeros__1" c_casadi__SX__zeros__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi__SX__zeros__1
+  :: Sparsity -> IO SX
+casadi__SX__zeros__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__zeros__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_zeros__1 :: Sparsity -> IO SX
+sx_zeros__1 = casadi__SX__zeros__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__zeros__2" c_casadi__SX__zeros__2
+  :: Ptr (Ptr StdString) -> IO (Ptr SX')
+
+casadi__SX__zeros__2
+  :: IO SX
+casadi__SX__zeros__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__zeros__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sx_zeros__2 :: IO SX
+sx_zeros__2 = casadi__SX__zeros__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__zeros__3" c_casadi__SX__zeros__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX')
+
+casadi__SX__zeros__3
+  :: Int -> IO SX
+casadi__SX__zeros__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__zeros__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_zeros__3 :: Int -> IO SX
+sx_zeros__3 = casadi__SX__zeros__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__zeros__4" c_casadi__SX__zeros__4
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX')
+
+casadi__SX__zeros__4
+  :: Int -> Int -> IO SX
+casadi__SX__zeros__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__zeros__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_zeros__4 :: Int -> Int -> IO SX
+sx_zeros__4 = casadi__SX__zeros__4
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__getRepresentation" c_casadi__SX__getRepresentation
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
+
+casadi__SX__getRepresentation
+  :: SX -> IO String
+casadi__SX__getRepresentation x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sx_getRepresentation :: SXClass a => a -> IO String
+sx_getRepresentation x = casadi__SX__getRepresentation (castSX x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SX__getDescription" c_casadi__SX__getDescription
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString)
+
+casadi__SX__getDescription
+  :: SX -> IO String
+casadi__SX__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SX__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/SXElem.hs b/Casadi/Core/Classes/SXElem.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/SXElem.hs
@@ -0,0 +1,31 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.SXElem
+       (
+         SXElem,
+         SXElemClass(..),
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
diff --git a/Casadi/Core/Classes/SXElement.hs b/Casadi/Core/Classes/SXElement.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/SXElement.hs
+++ /dev/null
@@ -1,31 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.SXElement
-       (
-         SXElement,
-         SXElementClass(..),
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
diff --git a/Casadi/Core/Classes/SXFunction.hs b/Casadi/Core/Classes/SXFunction.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/SXFunction.hs
+++ /dev/null
@@ -1,1428 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.SXFunction
-       (
-         SXFunction,
-         SXFunctionClass(..),
-         sxFunction__0,
-         sxFunction__1,
-         sxFunction__10,
-         sxFunction__2,
-         sxFunction__3,
-         sxFunction__4,
-         sxFunction__5,
-         sxFunction__6,
-         sxFunction__7,
-         sxFunction__8,
-         sxFunction__9,
-         sxFunction_clearSymbolic,
-         sxFunction_countNodes,
-         sxFunction_getAlgorithmSize,
-         sxFunction_getAtomicInput,
-         sxFunction_getAtomicInputReal,
-         sxFunction_getAtomicOperation,
-         sxFunction_getAtomicOutput,
-         sxFunction_getFree,
-         sxFunction_getWorkSize,
-         sxFunction_grad__0,
-         sxFunction_grad__1,
-         sxFunction_grad__2,
-         sxFunction_grad__3,
-         sxFunction_grad__4,
-         sxFunction_grad__5,
-         sxFunction_grad__6,
-         sxFunction_hess__0,
-         sxFunction_hess__1,
-         sxFunction_hess__2,
-         sxFunction_hess__3,
-         sxFunction_hess__4,
-         sxFunction_hess__5,
-         sxFunction_hess__6,
-         sxFunction_inputExpr__0,
-         sxFunction_inputExpr__1,
-         sxFunction_inputExpr__2,
-         sxFunction_jac__0,
-         sxFunction_jac__1,
-         sxFunction_jac__10,
-         sxFunction_jac__11,
-         sxFunction_jac__12,
-         sxFunction_jac__13,
-         sxFunction_jac__14,
-         sxFunction_jac__2,
-         sxFunction_jac__3,
-         sxFunction_jac__4,
-         sxFunction_jac__5,
-         sxFunction_jac__6,
-         sxFunction_jac__7,
-         sxFunction_jac__8,
-         sxFunction_jac__9,
-         sxFunction_outputExpr__0,
-         sxFunction_outputExpr__1,
-         sxFunction_outputExpr__2,
-         sxFunction_tang__0,
-         sxFunction_tang__1,
-         sxFunction_tang__2,
-         sxFunction_tang__3,
-         sxFunction_tang__4,
-         sxFunction_tang__5,
-         sxFunction_tang__6,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__0" c_casadi__SXFunction__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__0
-  :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__0 :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> IO SXFunction
-sxFunction__0 = casadi__SXFunction__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__1" c_casadi__SXFunction__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__1
-  :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__1 :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction
-sxFunction__1 = casadi__SXFunction__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__2" c_casadi__SXFunction__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__2
-  :: String -> Vector SX -> (M.Map String SX, Vector String) -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__2 :: String -> Vector SX -> (M.Map String SX, Vector String) -> IO SXFunction
-sxFunction__2 = casadi__SXFunction__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__3" c_casadi__SXFunction__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__3
-  :: String -> Vector SX -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__3 :: String -> Vector SX -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction
-sxFunction__3 = casadi__SXFunction__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__4" c_casadi__SXFunction__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__4
-  :: String -> (M.Map String SX, Vector String) -> Vector SX -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__4 :: String -> (M.Map String SX, Vector String) -> Vector SX -> IO SXFunction
-sxFunction__4 = casadi__SXFunction__CONSTRUCTOR__4
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__5" c_casadi__SXFunction__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__5
-  :: String -> (M.Map String SX, Vector String) -> Vector SX -> M.Map String GenericType -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__5 :: String -> (M.Map String SX, Vector String) -> Vector SX -> M.Map String GenericType -> IO SXFunction
-sxFunction__5 = casadi__SXFunction__CONSTRUCTOR__5
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__6" c_casadi__SXFunction__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__6
-  :: String -> Vector SX -> Vector SX -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__6 :: String -> Vector SX -> Vector SX -> IO SXFunction
-sxFunction__6 = casadi__SXFunction__CONSTRUCTOR__6
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__7" c_casadi__SXFunction__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__7
-  :: String -> Vector SX -> Vector SX -> M.Map String GenericType -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__7 :: String -> Vector SX -> Vector SX -> M.Map String GenericType -> IO SXFunction
-sxFunction__7 = casadi__SXFunction__CONSTRUCTOR__7
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__8" c_casadi__SXFunction__CONSTRUCTOR__8
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__8
-  :: Function -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__8 :: Function -> IO SXFunction
-sxFunction__8 = casadi__SXFunction__CONSTRUCTOR__8
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__9" c_casadi__SXFunction__CONSTRUCTOR__9
-  :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__9
-  :: MXFunction -> IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__9 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__9 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__9 :: MXFunction -> IO SXFunction
-sxFunction__9 = casadi__SXFunction__CONSTRUCTOR__9
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__10" c_casadi__SXFunction__CONSTRUCTOR__10
-  :: Ptr (Ptr StdString) -> IO (Ptr SXFunction')
-casadi__SXFunction__CONSTRUCTOR__10
-  :: IO SXFunction
-casadi__SXFunction__CONSTRUCTOR__10  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__CONSTRUCTOR__10 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction__10 :: IO SXFunction
-sxFunction__10 = casadi__SXFunction__CONSTRUCTOR__10
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__clearSymbolic" c_casadi__SXFunction__clearSymbolic
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO ()
-casadi__SXFunction__clearSymbolic
-  :: SXFunction -> IO ()
-casadi__SXFunction__clearSymbolic x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__clearSymbolic errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_clearSymbolic :: SXFunctionClass a => a -> IO ()
-sxFunction_clearSymbolic x = casadi__SXFunction__clearSymbolic (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__countNodes" c_casadi__SXFunction__countNodes
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO CInt
-casadi__SXFunction__countNodes
-  :: SXFunction -> IO Int
-casadi__SXFunction__countNodes x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__countNodes errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_countNodes :: SXFunctionClass a => a -> IO Int
-sxFunction_countNodes x = casadi__SXFunction__countNodes (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__getAlgorithmSize" c_casadi__SXFunction__getAlgorithmSize
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO CInt
-casadi__SXFunction__getAlgorithmSize
-  :: SXFunction -> IO Int
-casadi__SXFunction__getAlgorithmSize x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__getAlgorithmSize errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_getAlgorithmSize :: SXFunctionClass a => a -> IO Int
-sxFunction_getAlgorithmSize x = casadi__SXFunction__getAlgorithmSize (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__getAtomicInput" c_casadi__SXFunction__getAtomicInput
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr (StdPair CInt CInt))
-casadi__SXFunction__getAtomicInput
-  :: SXFunction -> Int -> IO (Int, Int)
-casadi__SXFunction__getAtomicInput x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__getAtomicInput errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_getAtomicInput :: SXFunctionClass a => a -> Int -> IO (Int, Int)
-sxFunction_getAtomicInput x = casadi__SXFunction__getAtomicInput (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__getAtomicInputReal" c_casadi__SXFunction__getAtomicInputReal
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO CDouble
-casadi__SXFunction__getAtomicInputReal
-  :: SXFunction -> Int -> IO Double
-casadi__SXFunction__getAtomicInputReal x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__getAtomicInputReal errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_getAtomicInputReal :: SXFunctionClass a => a -> Int -> IO Double
-sxFunction_getAtomicInputReal x = casadi__SXFunction__getAtomicInputReal (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__getAtomicOperation" c_casadi__SXFunction__getAtomicOperation
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO CInt
-casadi__SXFunction__getAtomicOperation
-  :: SXFunction -> Int -> IO Int
-casadi__SXFunction__getAtomicOperation x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__getAtomicOperation errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_getAtomicOperation :: SXFunctionClass a => a -> Int -> IO Int
-sxFunction_getAtomicOperation x = casadi__SXFunction__getAtomicOperation (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__getAtomicOutput" c_casadi__SXFunction__getAtomicOutput
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO CInt
-casadi__SXFunction__getAtomicOutput
-  :: SXFunction -> Int -> IO Int
-casadi__SXFunction__getAtomicOutput x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__getAtomicOutput errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_getAtomicOutput :: SXFunctionClass a => a -> Int -> IO Int
-sxFunction_getAtomicOutput x = casadi__SXFunction__getAtomicOutput (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__getFree" c_casadi__SXFunction__getFree
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO (Ptr SX')
-casadi__SXFunction__getFree
-  :: SXFunction -> IO SX
-casadi__SXFunction__getFree x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__getFree errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_getFree :: SXFunctionClass a => a -> IO SX
-sxFunction_getFree x = casadi__SXFunction__getFree (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__getWorkSize" c_casadi__SXFunction__getWorkSize
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO CInt
-casadi__SXFunction__getWorkSize
-  :: SXFunction -> IO Int
-casadi__SXFunction__getWorkSize x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__getWorkSize errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_getWorkSize :: SXFunctionClass a => a -> IO Int
-sxFunction_getWorkSize x = casadi__SXFunction__getWorkSize (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__grad__0" c_casadi__SXFunction__grad__0
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__grad__0
-  :: SXFunction -> String -> String -> IO SX
-casadi__SXFunction__grad__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__grad__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_grad__0 :: SXFunctionClass a => a -> String -> String -> IO SX
-sxFunction_grad__0 x = casadi__SXFunction__grad__0 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__grad__1" c_casadi__SXFunction__grad__1
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__grad__1
-  :: SXFunction -> Int -> String -> IO SX
-casadi__SXFunction__grad__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__grad__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_grad__1 :: SXFunctionClass a => a -> Int -> String -> IO SX
-sxFunction_grad__1 x = casadi__SXFunction__grad__1 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__grad__2" c_casadi__SXFunction__grad__2
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__grad__2
-  :: SXFunction -> String -> IO SX
-casadi__SXFunction__grad__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__grad__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_grad__2 :: SXFunctionClass a => a -> String -> IO SX
-sxFunction_grad__2 x = casadi__SXFunction__grad__2 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__grad__3" c_casadi__SXFunction__grad__3
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> CInt -> IO (Ptr SX')
-casadi__SXFunction__grad__3
-  :: SXFunction -> String -> Int -> IO SX
-casadi__SXFunction__grad__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__grad__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_grad__3 :: SXFunctionClass a => a -> String -> Int -> IO SX
-sxFunction_grad__3 x = casadi__SXFunction__grad__3 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__grad__4" c_casadi__SXFunction__grad__4
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO (Ptr SX')
-casadi__SXFunction__grad__4
-  :: SXFunction -> IO SX
-casadi__SXFunction__grad__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__grad__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_grad__4 :: SXFunctionClass a => a -> IO SX
-sxFunction_grad__4 x = casadi__SXFunction__grad__4 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__grad__5" c_casadi__SXFunction__grad__5
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr SX')
-casadi__SXFunction__grad__5
-  :: SXFunction -> Int -> IO SX
-casadi__SXFunction__grad__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__grad__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_grad__5 :: SXFunctionClass a => a -> Int -> IO SX
-sxFunction_grad__5 x = casadi__SXFunction__grad__5 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__grad__6" c_casadi__SXFunction__grad__6
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__grad__6
-  :: SXFunction -> Int -> Int -> IO SX
-casadi__SXFunction__grad__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__grad__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_grad__6 :: SXFunctionClass a => a -> Int -> Int -> IO SX
-sxFunction_grad__6 x = casadi__SXFunction__grad__6 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__hess__0" c_casadi__SXFunction__hess__0
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__hess__0
-  :: SXFunction -> String -> String -> IO SX
-casadi__SXFunction__hess__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__hess__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_hess__0 :: SXFunctionClass a => a -> String -> String -> IO SX
-sxFunction_hess__0 x = casadi__SXFunction__hess__0 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__hess__1" c_casadi__SXFunction__hess__1
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__hess__1
-  :: SXFunction -> Int -> String -> IO SX
-casadi__SXFunction__hess__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__hess__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_hess__1 :: SXFunctionClass a => a -> Int -> String -> IO SX
-sxFunction_hess__1 x = casadi__SXFunction__hess__1 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__hess__2" c_casadi__SXFunction__hess__2
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__hess__2
-  :: SXFunction -> String -> IO SX
-casadi__SXFunction__hess__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__hess__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_hess__2 :: SXFunctionClass a => a -> String -> IO SX
-sxFunction_hess__2 x = casadi__SXFunction__hess__2 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__hess__3" c_casadi__SXFunction__hess__3
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> CInt -> IO (Ptr SX')
-casadi__SXFunction__hess__3
-  :: SXFunction -> String -> Int -> IO SX
-casadi__SXFunction__hess__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__hess__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_hess__3 :: SXFunctionClass a => a -> String -> Int -> IO SX
-sxFunction_hess__3 x = casadi__SXFunction__hess__3 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__hess__4" c_casadi__SXFunction__hess__4
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO (Ptr SX')
-casadi__SXFunction__hess__4
-  :: SXFunction -> IO SX
-casadi__SXFunction__hess__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__hess__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_hess__4 :: SXFunctionClass a => a -> IO SX
-sxFunction_hess__4 x = casadi__SXFunction__hess__4 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__hess__5" c_casadi__SXFunction__hess__5
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr SX')
-casadi__SXFunction__hess__5
-  :: SXFunction -> Int -> IO SX
-casadi__SXFunction__hess__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__hess__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_hess__5 :: SXFunctionClass a => a -> Int -> IO SX
-sxFunction_hess__5 x = casadi__SXFunction__hess__5 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__hess__6" c_casadi__SXFunction__hess__6
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__hess__6
-  :: SXFunction -> Int -> Int -> IO SX
-casadi__SXFunction__hess__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__hess__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_hess__6 :: SXFunctionClass a => a -> Int -> Int -> IO SX
-sxFunction_hess__6 x = casadi__SXFunction__hess__6 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__inputExpr__0" c_casadi__SXFunction__inputExpr__0
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO (Ptr (StdVec (Ptr SX')))
-casadi__SXFunction__inputExpr__0
-  :: SXFunction -> IO (Vector SX)
-casadi__SXFunction__inputExpr__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__inputExpr__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_inputExpr__0 :: SXFunctionClass a => a -> IO (Vector SX)
-sxFunction_inputExpr__0 x = casadi__SXFunction__inputExpr__0 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__inputExpr__1" c_casadi__SXFunction__inputExpr__1
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__inputExpr__1
-  :: SXFunction -> String -> IO SX
-casadi__SXFunction__inputExpr__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__inputExpr__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_inputExpr__1 :: SXFunctionClass a => a -> String -> IO SX
-sxFunction_inputExpr__1 x = casadi__SXFunction__inputExpr__1 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__inputExpr__2" c_casadi__SXFunction__inputExpr__2
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr SX')
-casadi__SXFunction__inputExpr__2
-  :: SXFunction -> Int -> IO SX
-casadi__SXFunction__inputExpr__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__inputExpr__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_inputExpr__2 :: SXFunctionClass a => a -> Int -> IO SX
-sxFunction_inputExpr__2 x = casadi__SXFunction__inputExpr__2 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__0" c_casadi__SXFunction__jac__0
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__jac__0
-  :: SXFunction -> String -> String -> IO SX
-casadi__SXFunction__jac__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__0 :: SXFunctionClass a => a -> String -> String -> IO SX
-sxFunction_jac__0 x = casadi__SXFunction__jac__0 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__1" c_casadi__SXFunction__jac__1
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__1
-  :: SXFunction -> String -> String -> Bool -> IO SX
-casadi__SXFunction__jac__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__1 :: SXFunctionClass a => a -> String -> String -> Bool -> IO SX
-sxFunction_jac__1 x = casadi__SXFunction__jac__1 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__2" c_casadi__SXFunction__jac__2
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__2
-  :: SXFunction -> String -> String -> Bool -> Bool -> IO SX
-casadi__SXFunction__jac__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__2 :: SXFunctionClass a => a -> String -> String -> Bool -> Bool -> IO SX
-sxFunction_jac__2 x = casadi__SXFunction__jac__2 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__3" c_casadi__SXFunction__jac__3
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__jac__3
-  :: SXFunction -> Int -> String -> IO SX
-casadi__SXFunction__jac__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__3 :: SXFunctionClass a => a -> Int -> String -> IO SX
-sxFunction_jac__3 x = casadi__SXFunction__jac__3 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__4" c_casadi__SXFunction__jac__4
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> Ptr StdString -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__4
-  :: SXFunction -> Int -> String -> Bool -> IO SX
-casadi__SXFunction__jac__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__4 :: SXFunctionClass a => a -> Int -> String -> Bool -> IO SX
-sxFunction_jac__4 x = casadi__SXFunction__jac__4 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__5" c_casadi__SXFunction__jac__5
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__5
-  :: SXFunction -> Int -> String -> Bool -> Bool -> IO SX
-casadi__SXFunction__jac__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__5 :: SXFunctionClass a => a -> Int -> String -> Bool -> Bool -> IO SX
-sxFunction_jac__5 x = casadi__SXFunction__jac__5 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__6" c_casadi__SXFunction__jac__6
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__jac__6
-  :: SXFunction -> String -> IO SX
-casadi__SXFunction__jac__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__6 :: SXFunctionClass a => a -> String -> IO SX
-sxFunction_jac__6 x = casadi__SXFunction__jac__6 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__7" c_casadi__SXFunction__jac__7
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__7
-  :: SXFunction -> String -> Int -> IO SX
-casadi__SXFunction__jac__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__7 :: SXFunctionClass a => a -> String -> Int -> IO SX
-sxFunction_jac__7 x = casadi__SXFunction__jac__7 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__8" c_casadi__SXFunction__jac__8
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__8
-  :: SXFunction -> String -> Int -> Bool -> IO SX
-casadi__SXFunction__jac__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__8 :: SXFunctionClass a => a -> String -> Int -> Bool -> IO SX
-sxFunction_jac__8 x = casadi__SXFunction__jac__8 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__9" c_casadi__SXFunction__jac__9
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__9
-  :: SXFunction -> String -> Int -> Bool -> Bool -> IO SX
-casadi__SXFunction__jac__9 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__9 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__9 :: SXFunctionClass a => a -> String -> Int -> Bool -> Bool -> IO SX
-sxFunction_jac__9 x = casadi__SXFunction__jac__9 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__10" c_casadi__SXFunction__jac__10
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO (Ptr SX')
-casadi__SXFunction__jac__10
-  :: SXFunction -> IO SX
-casadi__SXFunction__jac__10 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__10 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__10 :: SXFunctionClass a => a -> IO SX
-sxFunction_jac__10 x = casadi__SXFunction__jac__10 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__11" c_casadi__SXFunction__jac__11
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__11
-  :: SXFunction -> Int -> IO SX
-casadi__SXFunction__jac__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__11 :: SXFunctionClass a => a -> Int -> IO SX
-sxFunction_jac__11 x = casadi__SXFunction__jac__11 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__12" c_casadi__SXFunction__jac__12
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__12
-  :: SXFunction -> Int -> Int -> IO SX
-casadi__SXFunction__jac__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__12 :: SXFunctionClass a => a -> Int -> Int -> IO SX
-sxFunction_jac__12 x = casadi__SXFunction__jac__12 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__13" c_casadi__SXFunction__jac__13
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__13
-  :: SXFunction -> Int -> Int -> Bool -> IO SX
-casadi__SXFunction__jac__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__13 :: SXFunctionClass a => a -> Int -> Int -> Bool -> IO SX
-sxFunction_jac__13 x = casadi__SXFunction__jac__13 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__jac__14" c_casadi__SXFunction__jac__14
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__jac__14
-  :: SXFunction -> Int -> Int -> Bool -> Bool -> IO SX
-casadi__SXFunction__jac__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__jac__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_jac__14 :: SXFunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO SX
-sxFunction_jac__14 x = casadi__SXFunction__jac__14 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__outputExpr__0" c_casadi__SXFunction__outputExpr__0
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO (Ptr (StdVec (Ptr SX')))
-casadi__SXFunction__outputExpr__0
-  :: SXFunction -> IO (Vector SX)
-casadi__SXFunction__outputExpr__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__outputExpr__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_outputExpr__0 :: SXFunctionClass a => a -> IO (Vector SX)
-sxFunction_outputExpr__0 x = casadi__SXFunction__outputExpr__0 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__outputExpr__1" c_casadi__SXFunction__outputExpr__1
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__outputExpr__1
-  :: SXFunction -> String -> IO SX
-casadi__SXFunction__outputExpr__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__outputExpr__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_outputExpr__1 :: SXFunctionClass a => a -> String -> IO SX
-sxFunction_outputExpr__1 x = casadi__SXFunction__outputExpr__1 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__outputExpr__2" c_casadi__SXFunction__outputExpr__2
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr SX')
-casadi__SXFunction__outputExpr__2
-  :: SXFunction -> Int -> IO SX
-casadi__SXFunction__outputExpr__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__outputExpr__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_outputExpr__2 :: SXFunctionClass a => a -> Int -> IO SX
-sxFunction_outputExpr__2 x = casadi__SXFunction__outputExpr__2 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__tang__0" c_casadi__SXFunction__tang__0
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__tang__0
-  :: SXFunction -> String -> String -> IO SX
-casadi__SXFunction__tang__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__tang__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_tang__0 :: SXFunctionClass a => a -> String -> String -> IO SX
-sxFunction_tang__0 x = casadi__SXFunction__tang__0 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__tang__1" c_casadi__SXFunction__tang__1
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__tang__1
-  :: SXFunction -> Int -> String -> IO SX
-casadi__SXFunction__tang__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__tang__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_tang__1 :: SXFunctionClass a => a -> Int -> String -> IO SX
-sxFunction_tang__1 x = casadi__SXFunction__tang__1 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__tang__2" c_casadi__SXFunction__tang__2
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> IO (Ptr SX')
-casadi__SXFunction__tang__2
-  :: SXFunction -> String -> IO SX
-casadi__SXFunction__tang__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__tang__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_tang__2 :: SXFunctionClass a => a -> String -> IO SX
-sxFunction_tang__2 x = casadi__SXFunction__tang__2 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__tang__3" c_casadi__SXFunction__tang__3
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> Ptr StdString -> CInt -> IO (Ptr SX')
-casadi__SXFunction__tang__3
-  :: SXFunction -> String -> Int -> IO SX
-casadi__SXFunction__tang__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__tang__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_tang__3 :: SXFunctionClass a => a -> String -> Int -> IO SX
-sxFunction_tang__3 x = casadi__SXFunction__tang__3 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__tang__4" c_casadi__SXFunction__tang__4
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> IO (Ptr SX')
-casadi__SXFunction__tang__4
-  :: SXFunction -> IO SX
-casadi__SXFunction__tang__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__tang__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_tang__4 :: SXFunctionClass a => a -> IO SX
-sxFunction_tang__4 x = casadi__SXFunction__tang__4 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__tang__5" c_casadi__SXFunction__tang__5
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr SX')
-casadi__SXFunction__tang__5
-  :: SXFunction -> Int -> IO SX
-casadi__SXFunction__tang__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__tang__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_tang__5 :: SXFunctionClass a => a -> Int -> IO SX
-sxFunction_tang__5 x = casadi__SXFunction__tang__5 (castSXFunction x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SXFunction__tang__6" c_casadi__SXFunction__tang__6
-  :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
-casadi__SXFunction__tang__6
-  :: SXFunction -> Int -> Int -> IO SX
-casadi__SXFunction__tang__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SXFunction__tang__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sxFunction_tang__6 :: SXFunctionClass a => a -> Int -> Int -> IO SX
-sxFunction_tang__6 x = casadi__SXFunction__tang__6 (castSXFunction x)
-
diff --git a/Casadi/Core/Classes/SdpSolver.hs b/Casadi/Core/Classes/SdpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/SdpSolver.hs
+++ /dev/null
@@ -1,161 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.SdpSolver
-       (
-         SdpSolver,
-         SdpSolverClass(..),
-         sdpSolver__0,
-         sdpSolver__1,
-         sdpSolver__2,
-         sdpSolver_doc,
-         sdpSolver_hasPlugin,
-         sdpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR__0" c_casadi__SdpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr SdpSolver')
-casadi__SdpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO SdpSolver
-casadi__SdpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdpSolver__0 :: String -> String -> M.Map String Sparsity -> IO SdpSolver
-sdpSolver__0 = casadi__SdpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR__1" c_casadi__SdpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SdpSolver')
-casadi__SdpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdpSolver
-casadi__SdpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdpSolver
-sdpSolver__1 = casadi__SdpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR__2" c_casadi__SdpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr SdpSolver')
-casadi__SdpSolver__CONSTRUCTOR__2
-  :: IO SdpSolver
-casadi__SdpSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdpSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdpSolver__2 :: IO SdpSolver
-sdpSolver__2 = casadi__SdpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdpSolver__doc" c_casadi__SdpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__SdpSolver__doc
-  :: String -> IO String
-casadi__SdpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdpSolver_doc :: String -> IO String
-sdpSolver_doc = casadi__SdpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdpSolver__hasPlugin" c_casadi__SdpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__SdpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__SdpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdpSolver_hasPlugin :: String -> IO Bool
-sdpSolver_hasPlugin = casadi__SdpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdpSolver__loadPlugin" c_casadi__SdpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__SdpSolver__loadPlugin
-  :: String -> IO ()
-casadi__SdpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdpSolver_loadPlugin :: String -> IO ()
-sdpSolver_loadPlugin = casadi__SdpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/SdqpSolver.hs b/Casadi/Core/Classes/SdqpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/SdqpSolver.hs
+++ /dev/null
@@ -1,161 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.SdqpSolver
-       (
-         SdqpSolver,
-         SdqpSolverClass(..),
-         sdqpSolver__0,
-         sdqpSolver__1,
-         sdqpSolver__2,
-         sdqpSolver_doc,
-         sdqpSolver_hasPlugin,
-         sdqpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR__0" c_casadi__SdqpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr SdqpSolver')
-casadi__SdqpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO SdqpSolver
-casadi__SdqpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdqpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdqpSolver__0 :: String -> String -> M.Map String Sparsity -> IO SdqpSolver
-sdqpSolver__0 = casadi__SdqpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR__1" c_casadi__SdqpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SdqpSolver')
-casadi__SdqpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdqpSolver
-casadi__SdqpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdqpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdqpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdqpSolver
-sdqpSolver__1 = casadi__SdqpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR__2" c_casadi__SdqpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr SdqpSolver')
-casadi__SdqpSolver__CONSTRUCTOR__2
-  :: IO SdqpSolver
-casadi__SdqpSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdqpSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdqpSolver__2 :: IO SdqpSolver
-sdqpSolver__2 = casadi__SdqpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdqpSolver__doc" c_casadi__SdqpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__SdqpSolver__doc
-  :: String -> IO String
-casadi__SdqpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdqpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdqpSolver_doc :: String -> IO String
-sdqpSolver_doc = casadi__SdqpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdqpSolver__hasPlugin" c_casadi__SdqpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__SdqpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__SdqpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdqpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdqpSolver_hasPlugin :: String -> IO Bool
-sdqpSolver_hasPlugin = casadi__SdqpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SdqpSolver__loadPlugin" c_casadi__SdqpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__SdqpSolver__loadPlugin
-  :: String -> IO ()
-casadi__SdqpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SdqpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sdqpSolver_loadPlugin :: String -> IO ()
-sdqpSolver_loadPlugin = casadi__SdqpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/SharedObject.hs b/Casadi/Core/Classes/SharedObject.hs
--- a/Casadi/Core/Classes/SharedObject.hs
+++ b/Casadi/Core/Classes/SharedObject.hs
@@ -10,15 +10,9 @@
          SharedObject,
          SharedObjectClass(..),
          sharedObject___hash__,
-         sharedObject_assertInit,
          sharedObject_getDescription,
          sharedObject_getRepresentation,
-         sharedObject_init__0,
-         sharedObject_init__1,
-         sharedObject_isInit,
-         sharedObject_isNull,
-         sharedObject_makeUnique__0,
-         sharedObject_makeUnique__1,
+         sharedObject_is_null,
          sharedObject_printPtr,
        ) where
 
@@ -36,187 +30,86 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__SharedObject____hash__" c_casadi__SharedObject____hash__
   :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO CSize
+
 casadi__SharedObject____hash__
   :: SharedObject -> IO CSize
-casadi__SharedObject____hash__ x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject____hash__ errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__SharedObject____hash__ x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SharedObject____hash__ errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
--- classy wrapper
-sharedObject___hash__ :: SharedObjectClass a => a -> IO CSize
-sharedObject___hash__ x = casadi__SharedObject____hash__ (castSharedObject x)
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
+  marshalFree x0 x0'
 
--- direct wrapper
-foreign import ccall unsafe "casadi__SharedObject__assertInit" c_casadi__SharedObject__assertInit
-  :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO ()
-casadi__SharedObject__assertInit
-  :: SharedObject -> IO ()
-casadi__SharedObject__assertInit x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__assertInit errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  return ret
 
 
--- classy wrapper
-sharedObject_assertInit :: SharedObjectClass a => a -> IO ()
-sharedObject_assertInit x = casadi__SharedObject__assertInit (castSharedObject x)
 
-
--- direct wrapper
-foreign import ccall safe "casadi__SharedObject__init__0" c_casadi__SharedObject__init__0
-  :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO ()
-casadi__SharedObject__init__0
-  :: SharedObject -> IO ()
-casadi__SharedObject__init__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__init__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
 -- classy wrapper
-sharedObject_init__0 :: SharedObjectClass a => a -> IO ()
-sharedObject_init__0 x = casadi__SharedObject__init__0 (castSharedObject x)
-
-
--- direct wrapper
-foreign import ccall safe "casadi__SharedObject__init__1" c_casadi__SharedObject__init__1
-  :: Ptr (Ptr StdString) -> Ptr SharedObject' -> CInt -> IO ()
-casadi__SharedObject__init__1
-  :: SharedObject -> Bool -> IO ()
-casadi__SharedObject__init__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__init__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sharedObject_init__1 :: SharedObjectClass a => a -> Bool -> IO ()
-sharedObject_init__1 x = casadi__SharedObject__init__1 (castSharedObject x)
+sharedObject___hash__ :: SharedObjectClass a => a -> IO CSize
+sharedObject___hash__ x = casadi__SharedObject____hash__ (castSharedObject x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__SharedObject__isInit" c_casadi__SharedObject__isInit
+foreign import ccall unsafe "casadi__SharedObject__is_null" c_casadi__SharedObject__is_null
   :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO CInt
-casadi__SharedObject__isInit
+
+casadi__SharedObject__is_null
   :: SharedObject -> IO Bool
-casadi__SharedObject__isInit x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__isInit errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__SharedObject__is_null x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SharedObject__is_null errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
--- classy wrapper
-sharedObject_isInit :: SharedObjectClass a => a -> IO Bool
-sharedObject_isInit x = casadi__SharedObject__isInit (castSharedObject x)
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
+  marshalFree x0 x0'
 
--- direct wrapper
-foreign import ccall unsafe "casadi__SharedObject__isNull" c_casadi__SharedObject__isNull
-  :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO CInt
-casadi__SharedObject__isNull
-  :: SharedObject -> IO Bool
-casadi__SharedObject__isNull x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__isNull errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  return ret
 
 
+
 -- classy wrapper
-sharedObject_isNull :: SharedObjectClass a => a -> IO Bool
-sharedObject_isNull x = casadi__SharedObject__isNull (castSharedObject x)
+sharedObject_is_null :: SharedObjectClass a => a -> IO Bool
+sharedObject_is_null x = casadi__SharedObject__is_null (castSharedObject x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__SharedObject__makeUnique__0" c_casadi__SharedObject__makeUnique__0
+foreign import ccall unsafe "casadi__SharedObject__printPtr" c_casadi__SharedObject__printPtr
   :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO ()
-casadi__SharedObject__makeUnique__0
+
+casadi__SharedObject__printPtr
   :: SharedObject -> IO ()
-casadi__SharedObject__makeUnique__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__makeUnique__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__SharedObject__printPtr x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SharedObject__printPtr errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
--- classy wrapper
-sharedObject_makeUnique__0 :: SharedObjectClass a => a -> IO ()
-sharedObject_makeUnique__0 x = casadi__SharedObject__makeUnique__0 (castSharedObject x)
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
+  marshalFree x0 x0'
 
--- direct wrapper
-foreign import ccall unsafe "casadi__SharedObject__makeUnique__1" c_casadi__SharedObject__makeUnique__1
-  :: Ptr (Ptr StdString) -> Ptr SharedObject' -> CInt -> IO ()
-casadi__SharedObject__makeUnique__1
-  :: SharedObject -> Bool -> IO ()
-casadi__SharedObject__makeUnique__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__makeUnique__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  return ()
 
 
--- classy wrapper
-sharedObject_makeUnique__1 :: SharedObjectClass a => a -> Bool -> IO ()
-sharedObject_makeUnique__1 x = casadi__SharedObject__makeUnique__1 (castSharedObject x)
 
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SharedObject__printPtr" c_casadi__SharedObject__printPtr
-  :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO ()
-casadi__SharedObject__printPtr
-  :: SharedObject -> IO ()
-casadi__SharedObject__printPtr x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__printPtr errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
 -- classy wrapper
 sharedObject_printPtr :: SharedObjectClass a => a -> IO ()
 sharedObject_printPtr x = casadi__SharedObject__printPtr (castSharedObject x)
@@ -225,18 +118,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__SharedObject__getRepresentation" c_casadi__SharedObject__getRepresentation
   :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO (Ptr StdString)
+
 casadi__SharedObject__getRepresentation
   :: SharedObject -> IO String
-casadi__SharedObject__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__SharedObject__getRepresentation x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SharedObject__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 sharedObject_getRepresentation :: SharedObjectClass a => a -> IO String
 sharedObject_getRepresentation x = casadi__SharedObject__getRepresentation (castSharedObject x)
@@ -245,16 +145,23 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__SharedObject__getDescription" c_casadi__SharedObject__getDescription
   :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO (Ptr StdString)
+
 casadi__SharedObject__getDescription
   :: SharedObject -> IO String
-casadi__SharedObject__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SharedObject__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__SharedObject__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__SharedObject__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/Simulator.hs b/Casadi/Core/Classes/Simulator.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/Simulator.hs
+++ /dev/null
@@ -1,147 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.Simulator
-       (
-         Simulator,
-         SimulatorClass(..),
-         simulator__0,
-         simulator__1,
-         simulator__2,
-         simulator__3,
-         simulator__4,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__0" c_casadi__Simulator__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr DMatrix' -> IO (Ptr Simulator')
-casadi__Simulator__CONSTRUCTOR__0
-  :: String -> Integrator -> DMatrix -> IO Simulator
-casadi__Simulator__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Simulator__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-simulator__0 :: String -> Integrator -> DMatrix -> IO Simulator
-simulator__0 = casadi__Simulator__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__1" c_casadi__Simulator__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Simulator')
-casadi__Simulator__CONSTRUCTOR__1
-  :: String -> Integrator -> DMatrix -> M.Map String GenericType -> IO Simulator
-casadi__Simulator__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Simulator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-simulator__1 :: String -> Integrator -> DMatrix -> M.Map String GenericType -> IO Simulator
-simulator__1 = casadi__Simulator__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__2" c_casadi__Simulator__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr Simulator')
-casadi__Simulator__CONSTRUCTOR__2
-  :: String -> Integrator -> Function -> DMatrix -> IO Simulator
-casadi__Simulator__CONSTRUCTOR__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Simulator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-simulator__2 :: String -> Integrator -> Function -> DMatrix -> IO Simulator
-simulator__2 = casadi__Simulator__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__3" c_casadi__Simulator__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr Function' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Simulator')
-casadi__Simulator__CONSTRUCTOR__3
-  :: String -> Integrator -> Function -> DMatrix -> M.Map String GenericType -> IO Simulator
-casadi__Simulator__CONSTRUCTOR__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Simulator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-simulator__3 :: String -> Integrator -> Function -> DMatrix -> M.Map String GenericType -> IO Simulator
-simulator__3 = casadi__Simulator__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__4" c_casadi__Simulator__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> IO (Ptr Simulator')
-casadi__Simulator__CONSTRUCTOR__4
-  :: IO Simulator
-casadi__Simulator__CONSTRUCTOR__4  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Simulator__CONSTRUCTOR__4 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-simulator__4 :: IO Simulator
-simulator__4 = casadi__Simulator__CONSTRUCTOR__4
-
diff --git a/Casadi/Core/Classes/Slice.hs b/Casadi/Core/Classes/Slice.hs
--- a/Casadi/Core/Classes/Slice.hs
+++ b/Casadi/Core/Classes/Slice.hs
@@ -14,21 +14,15 @@
          slice__2,
          slice__3,
          slice__4,
-         slice__5,
-         slice__6,
-         slice__7,
-         slice_getAll__0,
-         slice_getAll__1,
-         slice_getAll__2,
+         slice_all__0,
+         slice_all__1,
+         slice_all__2,
          slice_getDescription,
          slice_getRepresentation,
-         slice_isSlice2,
-         slice_isSlice__0,
-         slice_isSlice__1,
-         slice_isscalar,
-         slice_operator_equals,
-         slice_operator_nequals,
-         slice_toScalar,
+         slice_is_scalar,
+         slice_operator__equals,
+         slice_operator__nequals,
+         slice_scalar,
        ) where
 
 
@@ -45,401 +39,382 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__0" c_casadi__Slice__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr Slice' -> IO (Ptr Slice')
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Slice')
+
 casadi__Slice__CONSTRUCTOR__0
-  :: Vector Int -> Slice -> IO Slice
-casadi__Slice__CONSTRUCTOR__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  :: Int -> Int -> IO Slice
+casadi__Slice__CONSTRUCTOR__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__CONSTRUCTOR__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
-slice__0 :: Vector Int -> Slice -> IO Slice
+slice__0 :: Int -> Int -> IO Slice
 slice__0 = casadi__Slice__CONSTRUCTOR__0
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__1" c_casadi__Slice__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr Slice')
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> CInt -> IO (Ptr Slice')
+
 casadi__Slice__CONSTRUCTOR__1
-  :: Vector Int -> IO Slice
-casadi__Slice__CONSTRUCTOR__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  :: Int -> Int -> Int -> IO Slice
+casadi__Slice__CONSTRUCTOR__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__CONSTRUCTOR__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
 -- classy wrapper
-slice__1 :: Vector Int -> IO Slice
+slice__1 :: Int -> Int -> Int -> IO Slice
 slice__1 = casadi__Slice__CONSTRUCTOR__1
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__2" c_casadi__Slice__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Slice')
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Slice')
+
 casadi__Slice__CONSTRUCTOR__2
-  :: Vector Int -> Bool -> IO Slice
-casadi__Slice__CONSTRUCTOR__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  :: Int -> IO Slice
+casadi__Slice__CONSTRUCTOR__2 x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__CONSTRUCTOR__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
-slice__2 :: Vector Int -> Bool -> IO Slice
+slice__2 :: Int -> IO Slice
 slice__2 = casadi__Slice__CONSTRUCTOR__2
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__3" c_casadi__Slice__CONSTRUCTOR__3
   :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Slice')
+
 casadi__Slice__CONSTRUCTOR__3
-  :: Int -> Int -> IO Slice
-casadi__Slice__CONSTRUCTOR__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  :: Int -> Bool -> IO Slice
+casadi__Slice__CONSTRUCTOR__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__CONSTRUCTOR__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
-slice__3 :: Int -> Int -> IO Slice
+slice__3 :: Int -> Bool -> IO Slice
 slice__3 = casadi__Slice__CONSTRUCTOR__3
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__4" c_casadi__Slice__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> CInt -> IO (Ptr Slice')
+  :: Ptr (Ptr StdString) -> IO (Ptr Slice')
+
 casadi__Slice__CONSTRUCTOR__4
-  :: Int -> Int -> Int -> IO Slice
-casadi__Slice__CONSTRUCTOR__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  :: IO Slice
+casadi__Slice__CONSTRUCTOR__4  = do
 
 
--- classy wrapper
-slice__4 :: Int -> Int -> Int -> IO Slice
-slice__4 = casadi__Slice__CONSTRUCTOR__4
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__CONSTRUCTOR__4 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
--- direct wrapper
-foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__5" c_casadi__Slice__CONSTRUCTOR__5
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Slice')
-casadi__Slice__CONSTRUCTOR__5
-  :: Int -> IO Slice
-casadi__Slice__CONSTRUCTOR__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
--- classy wrapper
-slice__5 :: Int -> IO Slice
-slice__5 = casadi__Slice__CONSTRUCTOR__5
+  return ret
 
 
--- direct wrapper
-foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__6" c_casadi__Slice__CONSTRUCTOR__6
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Slice')
-casadi__Slice__CONSTRUCTOR__6
-  :: Int -> Bool -> IO Slice
-casadi__Slice__CONSTRUCTOR__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
-
 -- classy wrapper
-slice__6 :: Int -> Bool -> IO Slice
-slice__6 = casadi__Slice__CONSTRUCTOR__6
+slice__4 :: IO Slice
+slice__4 = casadi__Slice__CONSTRUCTOR__4
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__7" c_casadi__Slice__CONSTRUCTOR__7
-  :: Ptr (Ptr StdString) -> IO (Ptr Slice')
-casadi__Slice__CONSTRUCTOR__7
-  :: IO Slice
-casadi__Slice__CONSTRUCTOR__7  =
+foreign import ccall unsafe "casadi__Slice__all__0" c_casadi__Slice__all__0
+  :: Ptr (Ptr StdString) -> Ptr Slice' -> Ptr Slice' -> CInt -> IO (Ptr (StdVec CInt))
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__CONSTRUCTOR__7 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__all__0
+  :: Slice -> Slice -> Int -> IO (Vector Int)
+casadi__Slice__all__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__all__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
--- classy wrapper
-slice__7 :: IO Slice
-slice__7 = casadi__Slice__CONSTRUCTOR__7
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
 
--- direct wrapper
-foreign import ccall unsafe "casadi__Slice__getAll__0" c_casadi__Slice__getAll__0
-  :: Ptr (Ptr StdString) -> Ptr Slice' -> Ptr Slice' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__Slice__getAll__0
-  :: Slice -> Slice -> Int -> IO (Vector Int)
-casadi__Slice__getAll__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__getAll__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  return ret
 
 
+
 -- classy wrapper
-slice_getAll__0 :: SliceClass a => a -> Slice -> Int -> IO (Vector Int)
-slice_getAll__0 x = casadi__Slice__getAll__0 (castSlice x)
+slice_all__0 :: SliceClass a => a -> Slice -> Int -> IO (Vector Int)
+slice_all__0 x = casadi__Slice__all__0 (castSlice x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__Slice__getAll__1" c_casadi__Slice__getAll__1
+foreign import ccall unsafe "casadi__Slice__all__1" c_casadi__Slice__all__1
   :: Ptr (Ptr StdString) -> Ptr Slice' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__Slice__getAll__1
+
+casadi__Slice__all__1
   :: Slice -> Int -> IO (Vector Int)
-casadi__Slice__getAll__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__getAll__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__all__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__all__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
--- classy wrapper
-slice_getAll__1 :: SliceClass a => a -> Int -> IO (Vector Int)
-slice_getAll__1 x = casadi__Slice__getAll__1 (castSlice x)
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
+  marshalFree x0 x0'
+  marshalFree x1 x1'
 
--- direct wrapper
-foreign import ccall unsafe "casadi__Slice__getAll__2" c_casadi__Slice__getAll__2
-  :: Ptr (Ptr StdString) -> Ptr Slice' -> CInt -> CInt -> IO (Ptr (StdVec CInt))
-casadi__Slice__getAll__2
-  :: Slice -> Int -> Bool -> IO (Vector Int)
-casadi__Slice__getAll__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__getAll__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  return ret
 
 
+
 -- classy wrapper
-slice_getAll__2 :: SliceClass a => a -> Int -> Bool -> IO (Vector Int)
-slice_getAll__2 x = casadi__Slice__getAll__2 (castSlice x)
+slice_all__1 :: SliceClass a => a -> Int -> IO (Vector Int)
+slice_all__1 x = casadi__Slice__all__1 (castSlice x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__Slice__isSlice__0" c_casadi__Slice__isSlice__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
-casadi__Slice__isSlice__0
-  :: Vector Int -> IO Bool
-casadi__Slice__isSlice__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__isSlice__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+foreign import ccall unsafe "casadi__Slice__all__2" c_casadi__Slice__all__2
+  :: Ptr (Ptr StdString) -> Ptr Slice' -> CInt -> CInt -> IO (Ptr (StdVec CInt))
 
+casadi__Slice__all__2
+  :: Slice -> Int -> Bool -> IO (Vector Int)
+casadi__Slice__all__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
 
--- classy wrapper
-slice_isSlice__0 :: Vector Int -> IO Bool
-slice_isSlice__0 = casadi__Slice__isSlice__0
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__all__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
 
--- direct wrapper
-foreign import ccall unsafe "casadi__Slice__isSlice__1" c_casadi__Slice__isSlice__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO CInt
-casadi__Slice__isSlice__1
-  :: Vector Int -> Bool -> IO Bool
-casadi__Slice__isSlice__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__isSlice__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
 
+  return ret
 
--- classy wrapper
-slice_isSlice__1 :: Vector Int -> Bool -> IO Bool
-slice_isSlice__1 = casadi__Slice__isSlice__1
 
 
--- direct wrapper
-foreign import ccall unsafe "casadi__Slice__isSlice2" c_casadi__Slice__isSlice2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
-casadi__Slice__isSlice2
-  :: Vector Int -> IO Bool
-casadi__Slice__isSlice2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__isSlice2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
 -- classy wrapper
-slice_isSlice2 :: Vector Int -> IO Bool
-slice_isSlice2 = casadi__Slice__isSlice2
+slice_all__2 :: SliceClass a => a -> Int -> Bool -> IO (Vector Int)
+slice_all__2 x = casadi__Slice__all__2 (castSlice x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__Slice__isscalar" c_casadi__Slice__isscalar
+foreign import ccall unsafe "casadi__Slice__is_scalar" c_casadi__Slice__is_scalar
   :: Ptr (Ptr StdString) -> Ptr Slice' -> CInt -> IO CInt
-casadi__Slice__isscalar
+
+casadi__Slice__is_scalar
   :: Slice -> Int -> IO Bool
-casadi__Slice__isscalar x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__isscalar errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__is_scalar x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__is_scalar errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
-slice_isscalar :: SliceClass a => a -> Int -> IO Bool
-slice_isscalar x = casadi__Slice__isscalar (castSlice x)
+slice_is_scalar :: SliceClass a => a -> Int -> IO Bool
+slice_is_scalar x = casadi__Slice__is_scalar (castSlice x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__Slice__operator_nequals" c_casadi__Slice__operator_nequals
+foreign import ccall unsafe "casadi__Slice__operator__nequals" c_casadi__Slice__operator__nequals
   :: Ptr (Ptr StdString) -> Ptr Slice' -> Ptr Slice' -> IO CInt
-casadi__Slice__operator_nequals
+
+casadi__Slice__operator__nequals
   :: Slice -> Slice -> IO Bool
-casadi__Slice__operator_nequals x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__operator_nequals errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__operator__nequals x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__operator__nequals errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
-slice_operator_nequals :: SliceClass a => a -> Slice -> IO Bool
-slice_operator_nequals x = casadi__Slice__operator_nequals (castSlice x)
+slice_operator__nequals :: SliceClass a => a -> Slice -> IO Bool
+slice_operator__nequals x = casadi__Slice__operator__nequals (castSlice x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__Slice__operator_equals" c_casadi__Slice__operator_equals
+foreign import ccall unsafe "casadi__Slice__operator__equals" c_casadi__Slice__operator__equals
   :: Ptr (Ptr StdString) -> Ptr Slice' -> Ptr Slice' -> IO CInt
-casadi__Slice__operator_equals
+
+casadi__Slice__operator__equals
   :: Slice -> Slice -> IO Bool
-casadi__Slice__operator_equals x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__operator_equals errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__operator__equals x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__operator__equals errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
-slice_operator_equals :: SliceClass a => a -> Slice -> IO Bool
-slice_operator_equals x = casadi__Slice__operator_equals (castSlice x)
+slice_operator__equals :: SliceClass a => a -> Slice -> IO Bool
+slice_operator__equals x = casadi__Slice__operator__equals (castSlice x)
 
 
 -- direct wrapper
-foreign import ccall unsafe "casadi__Slice__toScalar" c_casadi__Slice__toScalar
+foreign import ccall unsafe "casadi__Slice__scalar" c_casadi__Slice__scalar
   :: Ptr (Ptr StdString) -> Ptr Slice' -> CInt -> IO CInt
-casadi__Slice__toScalar
+
+casadi__Slice__scalar
   :: Slice -> Int -> IO Int
-casadi__Slice__toScalar x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__toScalar errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__scalar x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__scalar errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
-slice_toScalar :: SliceClass a => a -> Int -> IO Int
-slice_toScalar x = casadi__Slice__toScalar (castSlice x)
+slice_scalar :: SliceClass a => a -> Int -> IO Int
+slice_scalar x = casadi__Slice__scalar (castSlice x)
 
 
 -- direct wrapper
 foreign import ccall unsafe "casadi__Slice__getRepresentation" c_casadi__Slice__getRepresentation
   :: Ptr (Ptr StdString) -> Ptr Slice' -> IO (Ptr StdString)
+
 casadi__Slice__getRepresentation
   :: Slice -> IO String
-casadi__Slice__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__getRepresentation x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 slice_getRepresentation :: SliceClass a => a -> IO String
 slice_getRepresentation x = casadi__Slice__getRepresentation (castSlice x)
@@ -448,16 +423,23 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Slice__getDescription" c_casadi__Slice__getDescription
   :: Ptr (Ptr StdString) -> Ptr Slice' -> IO (Ptr StdString)
+
 casadi__Slice__getDescription
   :: Slice -> IO String
-casadi__Slice__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Slice__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Slice__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Slice__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/SocpSolver.hs b/Casadi/Core/Classes/SocpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/SocpSolver.hs
+++ /dev/null
@@ -1,161 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.SocpSolver
-       (
-         SocpSolver,
-         SocpSolverClass(..),
-         socpSolver__0,
-         socpSolver__1,
-         socpSolver__2,
-         socpSolver_doc,
-         socpSolver_hasPlugin,
-         socpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR__0" c_casadi__SocpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr SocpSolver')
-casadi__SocpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO SocpSolver
-casadi__SocpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SocpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-socpSolver__0 :: String -> String -> M.Map String Sparsity -> IO SocpSolver
-socpSolver__0 = casadi__SocpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR__1" c_casadi__SocpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SocpSolver')
-casadi__SocpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SocpSolver
-casadi__SocpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SocpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-socpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SocpSolver
-socpSolver__1 = casadi__SocpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR__2" c_casadi__SocpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr SocpSolver')
-casadi__SocpSolver__CONSTRUCTOR__2
-  :: IO SocpSolver
-casadi__SocpSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SocpSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-socpSolver__2 :: IO SocpSolver
-socpSolver__2 = casadi__SocpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SocpSolver__doc" c_casadi__SocpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__SocpSolver__doc
-  :: String -> IO String
-casadi__SocpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SocpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-socpSolver_doc :: String -> IO String
-socpSolver_doc = casadi__SocpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SocpSolver__hasPlugin" c_casadi__SocpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__SocpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__SocpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SocpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-socpSolver_hasPlugin :: String -> IO Bool
-socpSolver_hasPlugin = casadi__SocpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SocpSolver__loadPlugin" c_casadi__SocpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__SocpSolver__loadPlugin
-  :: String -> IO ()
-casadi__SocpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SocpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-socpSolver_loadPlugin :: String -> IO ()
-socpSolver_loadPlugin = casadi__SocpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/Sparsity.hs b/Casadi/Core/Classes/Sparsity.hs
--- a/Casadi/Core/Classes/Sparsity.hs
+++ b/Casadi/Core/Classes/Sparsity.hs
@@ -14,3097 +14,4051 @@
          sparsity__1,
          sparsity__2,
          sparsity__3,
-         sparsity_addNZ,
-         sparsity_append,
-         sparsity_appendColumns,
-         sparsity_band,
-         sparsity_banded,
-         sparsity_bandwidthL,
-         sparsity_bandwidthU,
-         sparsity_clearCache,
-         sparsity_colind,
-         sparsity_compress,
-         sparsity_compressed,
-         sparsity_dense__0,
-         sparsity_dense__1,
-         sparsity_dense__2,
-         sparsity_depthFirstSearch,
-         sparsity_diag__0,
-         sparsity_diag__1,
-         sparsity_diag__2,
-         sparsity_dimString,
-         sparsity_dulmageMendelsohn__0,
-         sparsity_dulmageMendelsohn__1,
-         sparsity_eliminationTree__0,
-         sparsity_eliminationTree__1,
-         sparsity_enlargeColumns__0,
-         sparsity_enlargeColumns__1,
-         sparsity_enlargeRows__0,
-         sparsity_enlargeRows__1,
-         sparsity_enlarge__0,
-         sparsity_enlarge__1,
-         sparsity_erase__0,
-         sparsity_erase__1,
-         sparsity_erase__2,
-         sparsity_erase__3,
-         sparsity_find__0,
-         sparsity_find__1,
-         sparsity_getCCS,
-         sparsity_getCRS,
-         sparsity_getCol,
-         sparsity_getColind,
-         sparsity_getDiag,
-         sparsity_getLowerNZ,
-         sparsity_getNZ__0,
-         sparsity_getNZ__1,
-         sparsity_getNZ__2,
-         sparsity_getRow,
-         sparsity_getTriplet,
-         sparsity_getUpperNZ,
-         sparsity_hasNZ,
-         sparsity_hash,
-         sparsity_isEqual__0,
-         sparsity_isEqual__1,
-         sparsity_isReshape,
-         sparsity_isTranspose,
-         sparsity_iscolumn,
-         sparsity_isdense,
-         sparsity_isdiag,
-         sparsity_isempty__0,
-         sparsity_isempty__1,
-         sparsity_isrow,
-         sparsity_isscalar__0,
-         sparsity_isscalar__1,
-         sparsity_issingular,
-         sparsity_issquare,
-         sparsity_issymmetric,
-         sparsity_istril,
-         sparsity_istriu,
-         sparsity_isvector,
-         sparsity_largestFirstOrdering,
-         sparsity_lower,
-         sparsity_makeDense,
-         sparsity_nnz,
-         sparsity_numel,
-         sparsity_operator_equals,
-         sparsity_operator_mul,
-         sparsity_operator_nequals,
-         sparsity_operator_plus,
-         sparsity_patternCombine,
-         sparsity_patternIntersection,
-         sparsity_patternInverse,
-         sparsity_patternProduct,
-         sparsity_patternUnion,
-         sparsity_pmult__0,
-         sparsity_pmult__1,
-         sparsity_pmult__2,
-         sparsity_pmult__3,
-         sparsity_printCompact,
-         sparsity_reCache,
-         sparsity_removeDuplicates,
-         sparsity_reserve,
-         sparsity_resize,
-         sparsity_row,
-         sparsity_rowcol,
-         sparsity_rowsSequential__0,
-         sparsity_rowsSequential__1,
-         sparsity_sanityCheck__0,
-         sparsity_sanityCheck__1,
-         sparsity_scalar__0,
-         sparsity_scalar__1,
-         sparsity_shape,
-         sparsity_size1,
-         sparsity_size2,
-         sparsity_sizeD,
-         sparsity_sizeL,
-         sparsity_sizeU,
-         sparsity_sparse__0,
-         sparsity_sparse__1,
-         sparsity_sparse__2,
-         sparsity_spy,
-         sparsity_spyMatlab,
-         sparsity_starColoring2__0,
-         sparsity_starColoring2__1,
-         sparsity_starColoring2__2,
-         sparsity_starColoring__0,
-         sparsity_starColoring__1,
-         sparsity_starColoring__2,
-         sparsity_stronglyConnectedComponents,
-         sparsity_sub__0,
-         sparsity_sub__1,
-         sparsity_sub__2,
-         sparsity_sub__3,
-         sparsity_transpose__0,
-         sparsity_transpose__1,
-         sparsity_triplet__0,
-         sparsity_triplet__1,
-         sparsity_triplet__2,
-         sparsity_unidirectionalColoring__0,
-         sparsity_unidirectionalColoring__1,
-         sparsity_unidirectionalColoring__2,
-         sparsity_unit,
-         sparsity_upper,
-         sparsity_zz_tril__0,
-         sparsity_zz_tril__1,
-         sparsity_zz_triu__0,
-         sparsity_zz_triu__1,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__0" c_casadi__Sparsity__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__CONSTRUCTOR__0
-  :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
-casadi__Sparsity__CONSTRUCTOR__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
-sparsity__0 = casadi__Sparsity__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__1" c_casadi__Sparsity__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__CONSTRUCTOR__1
-  :: Int -> Int -> IO Sparsity
-casadi__Sparsity__CONSTRUCTOR__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__CONSTRUCTOR__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity__1 :: Int -> Int -> IO Sparsity
-sparsity__1 = casadi__Sparsity__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__2" c_casadi__Sparsity__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr Sparsity')
-casadi__Sparsity__CONSTRUCTOR__2
-  :: IO Sparsity
-casadi__Sparsity__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity__2 :: IO Sparsity
-sparsity__2 = casadi__Sparsity__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__3" c_casadi__Sparsity__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__CONSTRUCTOR__3
-  :: Int -> IO Sparsity
-casadi__Sparsity__CONSTRUCTOR__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__CONSTRUCTOR__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity__3 :: Int -> IO Sparsity
-sparsity__3 = casadi__Sparsity__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__T" c_casadi__Sparsity__T
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__T
-  :: Sparsity -> IO Sparsity
-casadi__Sparsity__T x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__T errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_T :: SparsityClass a => a -> IO Sparsity
-sparsity_T x = casadi__Sparsity__T (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__addNZ" c_casadi__Sparsity__addNZ
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
-casadi__Sparsity__addNZ
-  :: Sparsity -> Int -> Int -> IO Int
-casadi__Sparsity__addNZ x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__addNZ errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_addNZ :: SparsityClass a => a -> Int -> Int -> IO Int
-sparsity_addNZ x = casadi__Sparsity__addNZ (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__append" c_casadi__Sparsity__append
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO ()
-casadi__Sparsity__append
-  :: Sparsity -> Sparsity -> IO ()
-casadi__Sparsity__append x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__append errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_append :: SparsityClass a => a -> Sparsity -> IO ()
-sparsity_append x = casadi__Sparsity__append (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__appendColumns" c_casadi__Sparsity__appendColumns
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO ()
-casadi__Sparsity__appendColumns
-  :: Sparsity -> Sparsity -> IO ()
-casadi__Sparsity__appendColumns x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__appendColumns errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_appendColumns :: SparsityClass a => a -> Sparsity -> IO ()
-sparsity_appendColumns x = casadi__Sparsity__appendColumns (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__band" c_casadi__Sparsity__band
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__band
-  :: Int -> Int -> IO Sparsity
-casadi__Sparsity__band x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__band errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_band :: Int -> Int -> IO Sparsity
-sparsity_band = casadi__Sparsity__band
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__banded" c_casadi__Sparsity__banded
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__banded
-  :: Int -> Int -> IO Sparsity
-casadi__Sparsity__banded x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__banded errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_banded :: Int -> Int -> IO Sparsity
-sparsity_banded = casadi__Sparsity__banded
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__bandwidthL" c_casadi__Sparsity__bandwidthL
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__bandwidthL
-  :: Sparsity -> IO Int
-casadi__Sparsity__bandwidthL x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__bandwidthL errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_bandwidthL :: SparsityClass a => a -> IO Int
-sparsity_bandwidthL x = casadi__Sparsity__bandwidthL (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__bandwidthU" c_casadi__Sparsity__bandwidthU
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__bandwidthU
-  :: Sparsity -> IO Int
-casadi__Sparsity__bandwidthU x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__bandwidthU errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_bandwidthU :: SparsityClass a => a -> IO Int
-sparsity_bandwidthU x = casadi__Sparsity__bandwidthU (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__clearCache" c_casadi__Sparsity__clearCache
-  :: Ptr (Ptr StdString) -> IO ()
-casadi__Sparsity__clearCache
-  :: IO ()
-casadi__Sparsity__clearCache  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__clearCache errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_clearCache :: IO ()
-sparsity_clearCache = casadi__Sparsity__clearCache
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__colind" c_casadi__Sparsity__colind
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
-casadi__Sparsity__colind
-  :: Sparsity -> Int -> IO Int
-casadi__Sparsity__colind x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__colind errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_colind :: SparsityClass a => a -> Int -> IO Int
-sparsity_colind x = casadi__Sparsity__colind (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__compress" c_casadi__Sparsity__compress
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__compress
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__compress x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__compress errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_compress :: SparsityClass a => a -> IO (Vector Int)
-sparsity_compress x = casadi__Sparsity__compress (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__compressed" c_casadi__Sparsity__compressed
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__compressed
-  :: Vector Int -> IO Sparsity
-casadi__Sparsity__compressed x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__compressed errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_compressed :: Vector Int -> IO Sparsity
-sparsity_compressed = casadi__Sparsity__compressed
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__dense__0" c_casadi__Sparsity__dense__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__dense__0
-  :: (Int, Int) -> IO Sparsity
-casadi__Sparsity__dense__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__dense__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_dense__0 :: (Int, Int) -> IO Sparsity
-sparsity_dense__0 = casadi__Sparsity__dense__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__dense__1" c_casadi__Sparsity__dense__1
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__dense__1
-  :: Int -> IO Sparsity
-casadi__Sparsity__dense__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__dense__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_dense__1 :: Int -> IO Sparsity
-sparsity_dense__1 = casadi__Sparsity__dense__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__dense__2" c_casadi__Sparsity__dense__2
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__dense__2
-  :: Int -> Int -> IO Sparsity
-casadi__Sparsity__dense__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__dense__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_dense__2 :: Int -> Int -> IO Sparsity
-sparsity_dense__2 = casadi__Sparsity__dense__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__depthFirstSearch" c_casadi__Sparsity__depthFirstSearch
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
-casadi__Sparsity__depthFirstSearch
-  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int
-casadi__Sparsity__depthFirstSearch x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__depthFirstSearch errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_depthFirstSearch :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int
-sparsity_depthFirstSearch x = casadi__Sparsity__depthFirstSearch (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__diag__0" c_casadi__Sparsity__diag__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__diag__0
-  :: (Int, Int) -> IO Sparsity
-casadi__Sparsity__diag__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__diag__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_diag__0 :: (Int, Int) -> IO Sparsity
-sparsity_diag__0 = casadi__Sparsity__diag__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__diag__1" c_casadi__Sparsity__diag__1
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__diag__1
-  :: Int -> Int -> IO Sparsity
-casadi__Sparsity__diag__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__diag__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_diag__1 :: Int -> Int -> IO Sparsity
-sparsity_diag__1 = casadi__Sparsity__diag__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__diag__2" c_casadi__Sparsity__diag__2
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__diag__2
-  :: Int -> IO Sparsity
-casadi__Sparsity__diag__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__diag__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_diag__2 :: Int -> IO Sparsity
-sparsity_diag__2 = casadi__Sparsity__diag__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__dimString" c_casadi__Sparsity__dimString
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr StdString)
-casadi__Sparsity__dimString
-  :: Sparsity -> IO String
-casadi__Sparsity__dimString x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__dimString errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_dimString :: SparsityClass a => a -> IO String
-sparsity_dimString x = casadi__Sparsity__dimString (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__0" c_casadi__Sparsity__dulmageMendelsohn__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
-casadi__Sparsity__dulmageMendelsohn__0
-  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int
-casadi__Sparsity__dulmageMendelsohn__0 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__dulmageMendelsohn__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_dulmageMendelsohn__0 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int
-sparsity_dulmageMendelsohn__0 x = casadi__Sparsity__dulmageMendelsohn__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__1" c_casadi__Sparsity__dulmageMendelsohn__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO CInt
-casadi__Sparsity__dulmageMendelsohn__1
-  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int
-casadi__Sparsity__dulmageMendelsohn__1 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__dulmageMendelsohn__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_dulmageMendelsohn__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int
-sparsity_dulmageMendelsohn__1 x = casadi__Sparsity__dulmageMendelsohn__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__eliminationTree__0" c_casadi__Sparsity__eliminationTree__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__eliminationTree__0
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__eliminationTree__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__eliminationTree__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_eliminationTree__0 :: SparsityClass a => a -> IO (Vector Int)
-sparsity_eliminationTree__0 x = casadi__Sparsity__eliminationTree__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__eliminationTree__1" c_casadi__Sparsity__eliminationTree__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__eliminationTree__1
-  :: Sparsity -> Bool -> IO (Vector Int)
-casadi__Sparsity__eliminationTree__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__eliminationTree__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_eliminationTree__1 :: SparsityClass a => a -> Bool -> IO (Vector Int)
-sparsity_eliminationTree__1 x = casadi__Sparsity__eliminationTree__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__enlarge__0" c_casadi__Sparsity__enlarge__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__enlarge__0
-  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-casadi__Sparsity__enlarge__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_enlarge__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
-sparsity_enlarge__0 x = casadi__Sparsity__enlarge__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__enlarge__1" c_casadi__Sparsity__enlarge__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__Sparsity__enlarge__1
-  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-casadi__Sparsity__enlarge__1 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_enlarge__1 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
-sparsity_enlarge__1 x = casadi__Sparsity__enlarge__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__0" c_casadi__Sparsity__enlargeColumns__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__enlargeColumns__0
-  :: Sparsity -> Int -> Vector Int -> IO ()
-casadi__Sparsity__enlargeColumns__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__enlargeColumns__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_enlargeColumns__0 :: SparsityClass a => a -> Int -> Vector Int -> IO ()
-sparsity_enlargeColumns__0 x = casadi__Sparsity__enlargeColumns__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__1" c_casadi__Sparsity__enlargeColumns__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__Sparsity__enlargeColumns__1
-  :: Sparsity -> Int -> Vector Int -> Bool -> IO ()
-casadi__Sparsity__enlargeColumns__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__enlargeColumns__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_enlargeColumns__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO ()
-sparsity_enlargeColumns__1 x = casadi__Sparsity__enlargeColumns__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__enlargeRows__0" c_casadi__Sparsity__enlargeRows__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__enlargeRows__0
-  :: Sparsity -> Int -> Vector Int -> IO ()
-casadi__Sparsity__enlargeRows__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__enlargeRows__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_enlargeRows__0 :: SparsityClass a => a -> Int -> Vector Int -> IO ()
-sparsity_enlargeRows__0 x = casadi__Sparsity__enlargeRows__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__enlargeRows__1" c_casadi__Sparsity__enlargeRows__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO ()
-casadi__Sparsity__enlargeRows__1
-  :: Sparsity -> Int -> Vector Int -> Bool -> IO ()
-casadi__Sparsity__enlargeRows__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__enlargeRows__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_enlargeRows__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO ()
-sparsity_enlargeRows__1 x = casadi__Sparsity__enlargeRows__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__erase__0" c_casadi__Sparsity__erase__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__erase__0
-  :: Sparsity -> Vector Int -> IO (Vector Int)
-casadi__Sparsity__erase__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__erase__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_erase__0 :: SparsityClass a => a -> Vector Int -> IO (Vector Int)
-sparsity_erase__0 x = casadi__Sparsity__erase__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__erase__1" c_casadi__Sparsity__erase__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__erase__1
-  :: Sparsity -> Vector Int -> Bool -> IO (Vector Int)
-casadi__Sparsity__erase__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__erase__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_erase__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO (Vector Int)
-sparsity_erase__1 x = casadi__Sparsity__erase__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__erase__2" c_casadi__Sparsity__erase__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__erase__2
-  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int)
-casadi__Sparsity__erase__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__erase__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_erase__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
-sparsity_erase__2 x = casadi__Sparsity__erase__2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__erase__3" c_casadi__Sparsity__erase__3
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__erase__3
-  :: Sparsity -> Vector Int -> Vector Int -> Bool -> IO (Vector Int)
-casadi__Sparsity__erase__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__erase__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_erase__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Bool -> IO (Vector Int)
-sparsity_erase__3 x = casadi__Sparsity__erase__3 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__find__0" c_casadi__Sparsity__find__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__find__0
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__find__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__find__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_find__0 :: SparsityClass a => a -> IO (Vector Int)
-sparsity_find__0 x = casadi__Sparsity__find__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__find__1" c_casadi__Sparsity__find__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__find__1
-  :: Sparsity -> Bool -> IO (Vector Int)
-casadi__Sparsity__find__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__find__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_find__1 :: SparsityClass a => a -> Bool -> IO (Vector Int)
-sparsity_find__1 x = casadi__Sparsity__find__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getCCS" c_casadi__Sparsity__getCCS
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__getCCS
-  :: Sparsity -> Vector Int -> Vector Int -> IO ()
-casadi__Sparsity__getCCS x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getCCS errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getCCS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO ()
-sparsity_getCCS x = casadi__Sparsity__getCCS (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getCRS" c_casadi__Sparsity__getCRS
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__getCRS
-  :: Sparsity -> Vector Int -> Vector Int -> IO ()
-casadi__Sparsity__getCRS x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getCRS errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getCRS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO ()
-sparsity_getCRS x = casadi__Sparsity__getCRS (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getCol" c_casadi__Sparsity__getCol
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__getCol
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__getCol x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getCol errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getCol :: SparsityClass a => a -> IO (Vector Int)
-sparsity_getCol x = casadi__Sparsity__getCol (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getColind" c_casadi__Sparsity__getColind
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__getColind
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__getColind x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getColind errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getColind :: SparsityClass a => a -> IO (Vector Int)
-sparsity_getColind x = casadi__Sparsity__getColind (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getDiag" c_casadi__Sparsity__getDiag
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__getDiag
-  :: Sparsity -> Vector Int -> IO Sparsity
-casadi__Sparsity__getDiag x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getDiag errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getDiag :: SparsityClass a => a -> Vector Int -> IO Sparsity
-sparsity_getDiag x = casadi__Sparsity__getDiag (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getLowerNZ" c_casadi__Sparsity__getLowerNZ
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__getLowerNZ
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__getLowerNZ x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getLowerNZ errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getLowerNZ :: SparsityClass a => a -> IO (Vector Int)
-sparsity_getLowerNZ x = casadi__Sparsity__getLowerNZ (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getNZ__0" c_casadi__Sparsity__getNZ__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__getNZ__0
-  :: Sparsity -> Vector Int -> IO ()
-casadi__Sparsity__getNZ__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getNZ__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getNZ__0 :: SparsityClass a => a -> Vector Int -> IO ()
-sparsity_getNZ__0 x = casadi__Sparsity__getNZ__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getNZ__1" c_casadi__Sparsity__getNZ__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__getNZ__1
-  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int)
-casadi__Sparsity__getNZ__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getNZ__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getNZ__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
-sparsity_getNZ__1 x = casadi__Sparsity__getNZ__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getNZ__2" c_casadi__Sparsity__getNZ__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
-casadi__Sparsity__getNZ__2
-  :: Sparsity -> Int -> Int -> IO Int
-casadi__Sparsity__getNZ__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getNZ__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getNZ__2 :: SparsityClass a => a -> Int -> Int -> IO Int
-sparsity_getNZ__2 x = casadi__Sparsity__getNZ__2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getRow" c_casadi__Sparsity__getRow
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__getRow
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__getRow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getRow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getRow :: SparsityClass a => a -> IO (Vector Int)
-sparsity_getRow x = casadi__Sparsity__getRow (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getTriplet" c_casadi__Sparsity__getTriplet
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__getTriplet
-  :: Sparsity -> Vector Int -> Vector Int -> IO ()
-casadi__Sparsity__getTriplet x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getTriplet errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getTriplet :: SparsityClass a => a -> Vector Int -> Vector Int -> IO ()
-sparsity_getTriplet x = casadi__Sparsity__getTriplet (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__getUpperNZ" c_casadi__Sparsity__getUpperNZ
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__getUpperNZ
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__getUpperNZ x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__getUpperNZ errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_getUpperNZ :: SparsityClass a => a -> IO (Vector Int)
-sparsity_getUpperNZ x = casadi__Sparsity__getUpperNZ (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__hasNZ" c_casadi__Sparsity__hasNZ
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
-casadi__Sparsity__hasNZ
-  :: Sparsity -> Int -> Int -> IO Bool
-casadi__Sparsity__hasNZ x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__hasNZ errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_hasNZ :: SparsityClass a => a -> Int -> Int -> IO Bool
-sparsity_hasNZ x = casadi__Sparsity__hasNZ (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__hash" c_casadi__Sparsity__hash
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CSize
-casadi__Sparsity__hash
-  :: Sparsity -> IO CSize
-casadi__Sparsity__hash x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__hash errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_hash :: SparsityClass a => a -> IO CSize
-sparsity_hash x = casadi__Sparsity__hash (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isEqual__0" c_casadi__Sparsity__isEqual__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
-casadi__Sparsity__isEqual__0
-  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO Bool
-casadi__Sparsity__isEqual__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isEqual__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isEqual__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO Bool
-sparsity_isEqual__0 x = casadi__Sparsity__isEqual__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isEqual__1" c_casadi__Sparsity__isEqual__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isEqual__1
-  :: Sparsity -> Sparsity -> IO Bool
-casadi__Sparsity__isEqual__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isEqual__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isEqual__1 :: SparsityClass a => a -> Sparsity -> IO Bool
-sparsity_isEqual__1 x = casadi__Sparsity__isEqual__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isReshape" c_casadi__Sparsity__isReshape
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isReshape
-  :: Sparsity -> Sparsity -> IO Bool
-casadi__Sparsity__isReshape x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isReshape errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isReshape :: SparsityClass a => a -> Sparsity -> IO Bool
-sparsity_isReshape x = casadi__Sparsity__isReshape (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isTranspose" c_casadi__Sparsity__isTranspose
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isTranspose
-  :: Sparsity -> Sparsity -> IO Bool
-casadi__Sparsity__isTranspose x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isTranspose errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isTranspose :: SparsityClass a => a -> Sparsity -> IO Bool
-sparsity_isTranspose x = casadi__Sparsity__isTranspose (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__iscolumn" c_casadi__Sparsity__iscolumn
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__iscolumn
-  :: Sparsity -> IO Bool
-casadi__Sparsity__iscolumn x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__iscolumn errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_iscolumn :: SparsityClass a => a -> IO Bool
-sparsity_iscolumn x = casadi__Sparsity__iscolumn (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isdense" c_casadi__Sparsity__isdense
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isdense
-  :: Sparsity -> IO Bool
-casadi__Sparsity__isdense x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isdense errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isdense :: SparsityClass a => a -> IO Bool
-sparsity_isdense x = casadi__Sparsity__isdense (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isdiag" c_casadi__Sparsity__isdiag
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isdiag
-  :: Sparsity -> IO Bool
-casadi__Sparsity__isdiag x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isdiag errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isdiag :: SparsityClass a => a -> IO Bool
-sparsity_isdiag x = casadi__Sparsity__isdiag (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isempty__0" c_casadi__Sparsity__isempty__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isempty__0
-  :: Sparsity -> IO Bool
-casadi__Sparsity__isempty__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isempty__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isempty__0 :: SparsityClass a => a -> IO Bool
-sparsity_isempty__0 x = casadi__Sparsity__isempty__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isempty__1" c_casadi__Sparsity__isempty__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
-casadi__Sparsity__isempty__1
-  :: Sparsity -> Bool -> IO Bool
-casadi__Sparsity__isempty__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isempty__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isempty__1 :: SparsityClass a => a -> Bool -> IO Bool
-sparsity_isempty__1 x = casadi__Sparsity__isempty__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isrow" c_casadi__Sparsity__isrow
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isrow
-  :: Sparsity -> IO Bool
-casadi__Sparsity__isrow x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isrow errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isrow :: SparsityClass a => a -> IO Bool
-sparsity_isrow x = casadi__Sparsity__isrow (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isscalar__0" c_casadi__Sparsity__isscalar__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isscalar__0
-  :: Sparsity -> IO Bool
-casadi__Sparsity__isscalar__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isscalar__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isscalar__0 :: SparsityClass a => a -> IO Bool
-sparsity_isscalar__0 x = casadi__Sparsity__isscalar__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isscalar__1" c_casadi__Sparsity__isscalar__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
-casadi__Sparsity__isscalar__1
-  :: Sparsity -> Bool -> IO Bool
-casadi__Sparsity__isscalar__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isscalar__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isscalar__1 :: SparsityClass a => a -> Bool -> IO Bool
-sparsity_isscalar__1 x = casadi__Sparsity__isscalar__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__issingular" c_casadi__Sparsity__issingular
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__issingular
-  :: Sparsity -> IO Bool
-casadi__Sparsity__issingular x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__issingular errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_issingular :: SparsityClass a => a -> IO Bool
-sparsity_issingular x = casadi__Sparsity__issingular (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__issquare" c_casadi__Sparsity__issquare
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__issquare
-  :: Sparsity -> IO Bool
-casadi__Sparsity__issquare x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__issquare errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_issquare :: SparsityClass a => a -> IO Bool
-sparsity_issquare x = casadi__Sparsity__issquare (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__issymmetric" c_casadi__Sparsity__issymmetric
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__issymmetric
-  :: Sparsity -> IO Bool
-casadi__Sparsity__issymmetric x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__issymmetric errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_issymmetric :: SparsityClass a => a -> IO Bool
-sparsity_issymmetric x = casadi__Sparsity__issymmetric (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__istril" c_casadi__Sparsity__istril
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__istril
-  :: Sparsity -> IO Bool
-casadi__Sparsity__istril x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__istril errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_istril :: SparsityClass a => a -> IO Bool
-sparsity_istril x = casadi__Sparsity__istril (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__istriu" c_casadi__Sparsity__istriu
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__istriu
-  :: Sparsity -> IO Bool
-casadi__Sparsity__istriu x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__istriu errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_istriu :: SparsityClass a => a -> IO Bool
-sparsity_istriu x = casadi__Sparsity__istriu (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__isvector" c_casadi__Sparsity__isvector
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__isvector
-  :: Sparsity -> IO Bool
-casadi__Sparsity__isvector x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__isvector errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_isvector :: SparsityClass a => a -> IO Bool
-sparsity_isvector x = casadi__Sparsity__isvector (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__largestFirstOrdering" c_casadi__Sparsity__largestFirstOrdering
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
-casadi__Sparsity__largestFirstOrdering
-  :: Sparsity -> IO (Vector Int)
-casadi__Sparsity__largestFirstOrdering x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__largestFirstOrdering errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_largestFirstOrdering :: SparsityClass a => a -> IO (Vector Int)
-sparsity_largestFirstOrdering x = casadi__Sparsity__largestFirstOrdering (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__lower" c_casadi__Sparsity__lower
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__lower
-  :: Int -> IO Sparsity
-casadi__Sparsity__lower x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__lower errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_lower :: Int -> IO Sparsity
-sparsity_lower = casadi__Sparsity__lower
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__makeDense" c_casadi__Sparsity__makeDense
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__makeDense
-  :: Sparsity -> Vector Int -> IO Sparsity
-casadi__Sparsity__makeDense x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__makeDense errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_makeDense :: SparsityClass a => a -> Vector Int -> IO Sparsity
-sparsity_makeDense x = casadi__Sparsity__makeDense (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__nnz" c_casadi__Sparsity__nnz
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__nnz
-  :: Sparsity -> IO Int
-casadi__Sparsity__nnz x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__nnz errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_nnz :: SparsityClass a => a -> IO Int
-sparsity_nnz x = casadi__Sparsity__nnz (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__numel" c_casadi__Sparsity__numel
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__numel
-  :: Sparsity -> IO Int
-casadi__Sparsity__numel x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__numel errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_numel :: SparsityClass a => a -> IO Int
-sparsity_numel x = casadi__Sparsity__numel (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__operator_nequals" c_casadi__Sparsity__operator_nequals
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__operator_nequals
-  :: Sparsity -> Sparsity -> IO Bool
-casadi__Sparsity__operator_nequals x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__operator_nequals errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_operator_nequals :: SparsityClass a => a -> Sparsity -> IO Bool
-sparsity_operator_nequals x = casadi__Sparsity__operator_nequals (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__operator_mul" c_casadi__Sparsity__operator_mul
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__operator_mul
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi__Sparsity__operator_mul x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__operator_mul errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_operator_mul :: SparsityClass a => a -> Sparsity -> IO Sparsity
-sparsity_operator_mul x = casadi__Sparsity__operator_mul (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__operator_plus" c_casadi__Sparsity__operator_plus
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__operator_plus
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi__Sparsity__operator_plus x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__operator_plus errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_operator_plus :: SparsityClass a => a -> Sparsity -> IO Sparsity
-sparsity_operator_plus x = casadi__Sparsity__operator_plus (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__operator_equals" c_casadi__Sparsity__operator_equals
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__operator_equals
-  :: Sparsity -> Sparsity -> IO Bool
-casadi__Sparsity__operator_equals x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__operator_equals errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_operator_equals :: SparsityClass a => a -> Sparsity -> IO Bool
-sparsity_operator_equals x = casadi__Sparsity__operator_equals (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__patternCombine" c_casadi__Sparsity__patternCombine
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__patternCombine
-  :: Sparsity -> Sparsity -> Bool -> Bool -> IO Sparsity
-casadi__Sparsity__patternCombine x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__patternCombine errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_patternCombine :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> IO Sparsity
-sparsity_patternCombine x = casadi__Sparsity__patternCombine (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__patternIntersection" c_casadi__Sparsity__patternIntersection
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__patternIntersection
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi__Sparsity__patternIntersection x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__patternIntersection errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_patternIntersection :: SparsityClass a => a -> Sparsity -> IO Sparsity
-sparsity_patternIntersection x = casadi__Sparsity__patternIntersection (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__patternInverse" c_casadi__Sparsity__patternInverse
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__patternInverse
-  :: Sparsity -> IO Sparsity
-casadi__Sparsity__patternInverse x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__patternInverse errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_patternInverse :: SparsityClass a => a -> IO Sparsity
-sparsity_patternInverse x = casadi__Sparsity__patternInverse (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__patternProduct" c_casadi__Sparsity__patternProduct
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__patternProduct
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi__Sparsity__patternProduct x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__patternProduct errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_patternProduct :: SparsityClass a => a -> Sparsity -> IO Sparsity
-sparsity_patternProduct x = casadi__Sparsity__patternProduct (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__patternUnion" c_casadi__Sparsity__patternUnion
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__patternUnion
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi__Sparsity__patternUnion x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__patternUnion errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_patternUnion :: SparsityClass a => a -> Sparsity -> IO Sparsity
-sparsity_patternUnion x = casadi__Sparsity__patternUnion (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__pmult__0" c_casadi__Sparsity__pmult__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__pmult__0
-  :: Sparsity -> Vector Int -> IO Sparsity
-casadi__Sparsity__pmult__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__pmult__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_pmult__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity
-sparsity_pmult__0 x = casadi__Sparsity__pmult__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__pmult__1" c_casadi__Sparsity__pmult__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__pmult__1
-  :: Sparsity -> Vector Int -> Bool -> IO Sparsity
-casadi__Sparsity__pmult__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__pmult__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_pmult__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity
-sparsity_pmult__1 x = casadi__Sparsity__pmult__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__pmult__2" c_casadi__Sparsity__pmult__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__pmult__2
-  :: Sparsity -> Vector Int -> Bool -> Bool -> IO Sparsity
-casadi__Sparsity__pmult__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__pmult__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_pmult__2 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> IO Sparsity
-sparsity_pmult__2 x = casadi__Sparsity__pmult__2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__pmult__3" c_casadi__Sparsity__pmult__3
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__pmult__3
-  :: Sparsity -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity
-casadi__Sparsity__pmult__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__pmult__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_pmult__3 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity
-sparsity_pmult__3 x = casadi__Sparsity__pmult__3 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__printCompact" c_casadi__Sparsity__printCompact
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
-casadi__Sparsity__printCompact
-  :: Sparsity -> IO ()
-casadi__Sparsity__printCompact x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__printCompact errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_printCompact :: SparsityClass a => a -> IO ()
-sparsity_printCompact x = casadi__Sparsity__printCompact (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__reCache" c_casadi__Sparsity__reCache
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
-casadi__Sparsity__reCache
-  :: Sparsity -> IO ()
-casadi__Sparsity__reCache x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__reCache errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_reCache :: SparsityClass a => a -> IO ()
-sparsity_reCache x = casadi__Sparsity__reCache (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__removeDuplicates" c_casadi__Sparsity__removeDuplicates
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
-casadi__Sparsity__removeDuplicates
-  :: Sparsity -> Vector Int -> IO ()
-casadi__Sparsity__removeDuplicates x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__removeDuplicates errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_removeDuplicates :: SparsityClass a => a -> Vector Int -> IO ()
-sparsity_removeDuplicates x = casadi__Sparsity__removeDuplicates (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__reserve" c_casadi__Sparsity__reserve
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO ()
-casadi__Sparsity__reserve
-  :: Sparsity -> Int -> Int -> IO ()
-casadi__Sparsity__reserve x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__reserve errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_reserve :: SparsityClass a => a -> Int -> Int -> IO ()
-sparsity_reserve x = casadi__Sparsity__reserve (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__resize" c_casadi__Sparsity__resize
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO ()
-casadi__Sparsity__resize
-  :: Sparsity -> Int -> Int -> IO ()
-casadi__Sparsity__resize x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__resize errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_resize :: SparsityClass a => a -> Int -> Int -> IO ()
-sparsity_resize x = casadi__Sparsity__resize (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__row" c_casadi__Sparsity__row
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
-casadi__Sparsity__row
-  :: Sparsity -> Int -> IO Int
-casadi__Sparsity__row x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__row errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_row :: SparsityClass a => a -> Int -> IO Int
-sparsity_row x = casadi__Sparsity__row (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__rowcol" c_casadi__Sparsity__rowcol
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__rowcol
-  :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity
-casadi__Sparsity__rowcol x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__rowcol errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_rowcol :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity
-sparsity_rowcol = casadi__Sparsity__rowcol
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__rowsSequential__0" c_casadi__Sparsity__rowsSequential__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__rowsSequential__0
-  :: Sparsity -> IO Bool
-casadi__Sparsity__rowsSequential__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__rowsSequential__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_rowsSequential__0 :: SparsityClass a => a -> IO Bool
-sparsity_rowsSequential__0 x = casadi__Sparsity__rowsSequential__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__rowsSequential__1" c_casadi__Sparsity__rowsSequential__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
-casadi__Sparsity__rowsSequential__1
-  :: Sparsity -> Bool -> IO Bool
-casadi__Sparsity__rowsSequential__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__rowsSequential__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_rowsSequential__1 :: SparsityClass a => a -> Bool -> IO Bool
-sparsity_rowsSequential__1 x = casadi__Sparsity__rowsSequential__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sanityCheck__0" c_casadi__Sparsity__sanityCheck__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
-casadi__Sparsity__sanityCheck__0
-  :: Sparsity -> IO ()
-casadi__Sparsity__sanityCheck__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sanityCheck__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sanityCheck__0 :: SparsityClass a => a -> IO ()
-sparsity_sanityCheck__0 x = casadi__Sparsity__sanityCheck__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sanityCheck__1" c_casadi__Sparsity__sanityCheck__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO ()
-casadi__Sparsity__sanityCheck__1
-  :: Sparsity -> Bool -> IO ()
-casadi__Sparsity__sanityCheck__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sanityCheck__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sanityCheck__1 :: SparsityClass a => a -> Bool -> IO ()
-sparsity_sanityCheck__1 x = casadi__Sparsity__sanityCheck__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__scalar__0" c_casadi__Sparsity__scalar__0
-  :: Ptr (Ptr StdString) -> IO (Ptr Sparsity')
-casadi__Sparsity__scalar__0
-  :: IO Sparsity
-casadi__Sparsity__scalar__0  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__scalar__0 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_scalar__0 :: IO Sparsity
-sparsity_scalar__0 = casadi__Sparsity__scalar__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__scalar__1" c_casadi__Sparsity__scalar__1
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__scalar__1
-  :: Bool -> IO Sparsity
-casadi__Sparsity__scalar__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__scalar__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_scalar__1 :: Bool -> IO Sparsity
-sparsity_scalar__1 = casadi__Sparsity__scalar__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__shape" c_casadi__Sparsity__shape
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdPair CInt CInt))
-casadi__Sparsity__shape
-  :: Sparsity -> IO (Int, Int)
-casadi__Sparsity__shape x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__shape errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_shape :: SparsityClass a => a -> IO (Int, Int)
-sparsity_shape x = casadi__Sparsity__shape (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__size1" c_casadi__Sparsity__size1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__size1
-  :: Sparsity -> IO Int
-casadi__Sparsity__size1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__size1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_size1 :: SparsityClass a => a -> IO Int
-sparsity_size1 x = casadi__Sparsity__size1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__size2" c_casadi__Sparsity__size2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__size2
-  :: Sparsity -> IO Int
-casadi__Sparsity__size2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__size2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_size2 :: SparsityClass a => a -> IO Int
-sparsity_size2 x = casadi__Sparsity__size2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sizeD" c_casadi__Sparsity__sizeD
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__sizeD
-  :: Sparsity -> IO Int
-casadi__Sparsity__sizeD x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sizeD errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sizeD :: SparsityClass a => a -> IO Int
-sparsity_sizeD x = casadi__Sparsity__sizeD (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sizeL" c_casadi__Sparsity__sizeL
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__sizeL
-  :: Sparsity -> IO Int
-casadi__Sparsity__sizeL x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sizeL errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sizeL :: SparsityClass a => a -> IO Int
-sparsity_sizeL x = casadi__Sparsity__sizeL (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sizeU" c_casadi__Sparsity__sizeU
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi__Sparsity__sizeU
-  :: Sparsity -> IO Int
-casadi__Sparsity__sizeU x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sizeU errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sizeU :: SparsityClass a => a -> IO Int
-sparsity_sizeU x = casadi__Sparsity__sizeU (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sparse__0" c_casadi__Sparsity__sparse__0
-  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__sparse__0
-  :: (Int, Int) -> IO Sparsity
-casadi__Sparsity__sparse__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sparse__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sparse__0 :: (Int, Int) -> IO Sparsity
-sparsity_sparse__0 = casadi__Sparsity__sparse__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sparse__1" c_casadi__Sparsity__sparse__1
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__sparse__1
-  :: Int -> IO Sparsity
-casadi__Sparsity__sparse__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sparse__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sparse__1 :: Int -> IO Sparsity
-sparsity_sparse__1 = casadi__Sparsity__sparse__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sparse__2" c_casadi__Sparsity__sparse__2
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__sparse__2
-  :: Int -> Int -> IO Sparsity
-casadi__Sparsity__sparse__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sparse__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sparse__2 :: Int -> Int -> IO Sparsity
-sparsity_sparse__2 = casadi__Sparsity__sparse__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__spy" c_casadi__Sparsity__spy
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
-casadi__Sparsity__spy
-  :: Sparsity -> IO ()
-casadi__Sparsity__spy x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__spy errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_spy :: SparsityClass a => a -> IO ()
-sparsity_spy x = casadi__Sparsity__spy (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__spyMatlab" c_casadi__Sparsity__spyMatlab
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr StdString -> IO ()
-casadi__Sparsity__spyMatlab
-  :: Sparsity -> String -> IO ()
-casadi__Sparsity__spyMatlab x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__spyMatlab errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_spyMatlab :: SparsityClass a => a -> String -> IO ()
-sparsity_spyMatlab x = casadi__Sparsity__spyMatlab (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__starColoring__0" c_casadi__Sparsity__starColoring__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__starColoring__0
-  :: Sparsity -> IO Sparsity
-casadi__Sparsity__starColoring__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__starColoring__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_starColoring__0 :: SparsityClass a => a -> IO Sparsity
-sparsity_starColoring__0 x = casadi__Sparsity__starColoring__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__starColoring__1" c_casadi__Sparsity__starColoring__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__starColoring__1
-  :: Sparsity -> Int -> IO Sparsity
-casadi__Sparsity__starColoring__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__starColoring__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_starColoring__1 :: SparsityClass a => a -> Int -> IO Sparsity
-sparsity_starColoring__1 x = casadi__Sparsity__starColoring__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__starColoring__2" c_casadi__Sparsity__starColoring__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__starColoring__2
-  :: Sparsity -> Int -> Int -> IO Sparsity
-casadi__Sparsity__starColoring__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__starColoring__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_starColoring__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
-sparsity_starColoring__2 x = casadi__Sparsity__starColoring__2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__starColoring2__0" c_casadi__Sparsity__starColoring2__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__starColoring2__0
-  :: Sparsity -> IO Sparsity
-casadi__Sparsity__starColoring2__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__starColoring2__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_starColoring2__0 :: SparsityClass a => a -> IO Sparsity
-sparsity_starColoring2__0 x = casadi__Sparsity__starColoring2__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__starColoring2__1" c_casadi__Sparsity__starColoring2__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__starColoring2__1
-  :: Sparsity -> Int -> IO Sparsity
-casadi__Sparsity__starColoring2__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__starColoring2__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_starColoring2__1 :: SparsityClass a => a -> Int -> IO Sparsity
-sparsity_starColoring2__1 x = casadi__Sparsity__starColoring2__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__starColoring2__2" c_casadi__Sparsity__starColoring2__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__starColoring2__2
-  :: Sparsity -> Int -> Int -> IO Sparsity
-casadi__Sparsity__starColoring2__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__starColoring2__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_starColoring2__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
-sparsity_starColoring2__2 x = casadi__Sparsity__starColoring2__2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__stronglyConnectedComponents" c_casadi__Sparsity__stronglyConnectedComponents
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
-casadi__Sparsity__stronglyConnectedComponents
-  :: Sparsity -> Vector Int -> Vector Int -> IO Int
-casadi__Sparsity__stronglyConnectedComponents x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__stronglyConnectedComponents errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_stronglyConnectedComponents :: SparsityClass a => a -> Vector Int -> Vector Int -> IO Int
-sparsity_stronglyConnectedComponents x = casadi__Sparsity__stronglyConnectedComponents (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sub__0" c_casadi__Sparsity__sub__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__sub__0
-  :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity
-casadi__Sparsity__sub__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sub__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sub__0 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity
-sparsity_sub__0 x = casadi__Sparsity__sub__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sub__1" c_casadi__Sparsity__sub__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__sub__1
-  :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity
-casadi__Sparsity__sub__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sub__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sub__1 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity
-sparsity_sub__1 x = casadi__Sparsity__sub__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sub__2" c_casadi__Sparsity__sub__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__sub__2
-  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
-casadi__Sparsity__sub__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sub__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sub__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
-sparsity_sub__2 x = casadi__Sparsity__sub__2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__sub__3" c_casadi__Sparsity__sub__3
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__sub__3
-  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
-casadi__Sparsity__sub__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__sub__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_sub__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
-sparsity_sub__3 x = casadi__Sparsity__sub__3 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__transpose__0" c_casadi__Sparsity__transpose__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__transpose__0
-  :: Sparsity -> Vector Int -> IO Sparsity
-casadi__Sparsity__transpose__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__transpose__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_transpose__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity
-sparsity_transpose__0 x = casadi__Sparsity__transpose__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__transpose__1" c_casadi__Sparsity__transpose__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__transpose__1
-  :: Sparsity -> Vector Int -> Bool -> IO Sparsity
-casadi__Sparsity__transpose__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__transpose__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_transpose__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity
-sparsity_transpose__1 x = casadi__Sparsity__transpose__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__triplet__0" c_casadi__Sparsity__triplet__0
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__triplet__0
-  :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
-casadi__Sparsity__triplet__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__triplet__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_triplet__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
-sparsity_triplet__0 = casadi__Sparsity__triplet__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__triplet__1" c_casadi__Sparsity__triplet__1
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
-casadi__Sparsity__triplet__1
-  :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
-casadi__Sparsity__triplet__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_triplet__1 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
-sparsity_triplet__1 = casadi__Sparsity__triplet__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__triplet__2" c_casadi__Sparsity__triplet__2
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__triplet__2
-  :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
-casadi__Sparsity__triplet__2 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__triplet__2 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_triplet__2 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
-sparsity_triplet__2 = casadi__Sparsity__triplet__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__0" c_casadi__Sparsity__unidirectionalColoring__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__unidirectionalColoring__0
-  :: Sparsity -> IO Sparsity
-casadi__Sparsity__unidirectionalColoring__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__unidirectionalColoring__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_unidirectionalColoring__0 :: SparsityClass a => a -> IO Sparsity
-sparsity_unidirectionalColoring__0 x = casadi__Sparsity__unidirectionalColoring__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__1" c_casadi__Sparsity__unidirectionalColoring__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__unidirectionalColoring__1
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi__Sparsity__unidirectionalColoring__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__unidirectionalColoring__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_unidirectionalColoring__1 :: SparsityClass a => a -> Sparsity -> IO Sparsity
-sparsity_unidirectionalColoring__1 x = casadi__Sparsity__unidirectionalColoring__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__2" c_casadi__Sparsity__unidirectionalColoring__2
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__unidirectionalColoring__2
-  :: Sparsity -> Sparsity -> Int -> IO Sparsity
-casadi__Sparsity__unidirectionalColoring__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__unidirectionalColoring__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_unidirectionalColoring__2 :: SparsityClass a => a -> Sparsity -> Int -> IO Sparsity
-sparsity_unidirectionalColoring__2 x = casadi__Sparsity__unidirectionalColoring__2 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__unit" c_casadi__Sparsity__unit
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__unit
-  :: Int -> Int -> IO Sparsity
-casadi__Sparsity__unit x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__unit errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_unit :: Int -> Int -> IO Sparsity
-sparsity_unit = casadi__Sparsity__unit
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__upper" c_casadi__Sparsity__upper
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__upper
-  :: Int -> IO Sparsity
-casadi__Sparsity__upper x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__upper errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_upper :: Int -> IO Sparsity
-sparsity_upper = casadi__Sparsity__upper
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__zz_tril__0" c_casadi__Sparsity__zz_tril__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__zz_tril__0
-  :: Sparsity -> IO Sparsity
-casadi__Sparsity__zz_tril__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__zz_tril__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_zz_tril__0 :: SparsityClass a => a -> IO Sparsity
-sparsity_zz_tril__0 x = casadi__Sparsity__zz_tril__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__zz_tril__1" c_casadi__Sparsity__zz_tril__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__zz_tril__1
-  :: Sparsity -> Bool -> IO Sparsity
-casadi__Sparsity__zz_tril__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__zz_tril__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_zz_tril__1 :: SparsityClass a => a -> Bool -> IO Sparsity
-sparsity_zz_tril__1 x = casadi__Sparsity__zz_tril__1 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__zz_triu__0" c_casadi__Sparsity__zz_triu__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi__Sparsity__zz_triu__0
-  :: Sparsity -> IO Sparsity
-casadi__Sparsity__zz_triu__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__zz_triu__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_zz_triu__0 :: SparsityClass a => a -> IO Sparsity
-sparsity_zz_triu__0 x = casadi__Sparsity__zz_triu__0 (castSparsity x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Sparsity__zz_triu__1" c_casadi__Sparsity__zz_triu__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi__Sparsity__zz_triu__1
-  :: Sparsity -> Bool -> IO Sparsity
-casadi__Sparsity__zz_triu__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Sparsity__zz_triu__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sparsity_zz_triu__1 :: SparsityClass a => a -> Bool -> IO Sparsity
-sparsity_zz_triu__1 x = casadi__Sparsity__zz_triu__1 (castSparsity x)
+         sparsity_add_nz,
+         sparsity_append,
+         sparsity_appendColumns,
+         sparsity_band,
+         sparsity_banded,
+         sparsity_btf__0,
+         sparsity_btf__1,
+         sparsity_bw_lower,
+         sparsity_bw_upper,
+         sparsity_colind,
+         sparsity_combine,
+         sparsity_compress,
+         sparsity_compressed,
+         sparsity_dense__0,
+         sparsity_dense__1,
+         sparsity_dense__2,
+         sparsity_dfs,
+         sparsity_diag__0,
+         sparsity_diag__1,
+         sparsity_diag__2,
+         sparsity_dim,
+         sparsity_enlargeColumns__0,
+         sparsity_enlargeColumns__1,
+         sparsity_enlargeRows__0,
+         sparsity_enlargeRows__1,
+         sparsity_enlarge__0,
+         sparsity_enlarge__1,
+         sparsity_erase__0,
+         sparsity_erase__1,
+         sparsity_erase__2,
+         sparsity_erase__3,
+         sparsity_etree__0,
+         sparsity_etree__1,
+         sparsity_find__0,
+         sparsity_find__1,
+         sparsity_get_ccs,
+         sparsity_get_col,
+         sparsity_get_colind,
+         sparsity_get_crs,
+         sparsity_get_diag,
+         sparsity_get_lower,
+         sparsity_get_nz__0,
+         sparsity_get_nz__1,
+         sparsity_get_nz__2,
+         sparsity_get_row,
+         sparsity_get_triplet,
+         sparsity_get_upper,
+         sparsity_has_nz,
+         sparsity_hash,
+         sparsity_intersect,
+         sparsity_isReshape,
+         sparsity_is_column,
+         sparsity_is_dense,
+         sparsity_is_diag,
+         sparsity_is_empty__0,
+         sparsity_is_empty__1,
+         sparsity_is_equal__0,
+         sparsity_is_equal__1,
+         sparsity_is_row,
+         sparsity_is_scalar__0,
+         sparsity_is_scalar__1,
+         sparsity_is_singular,
+         sparsity_is_square,
+         sparsity_is_symmetric,
+         sparsity_is_transpose,
+         sparsity_is_tril,
+         sparsity_is_triu,
+         sparsity_is_vector,
+         sparsity_largest_first,
+         sparsity_lower,
+         sparsity_makeDense,
+         sparsity_nnz,
+         sparsity_nnz_diag,
+         sparsity_nnz_lower__0,
+         sparsity_nnz_lower__1,
+         sparsity_nnz_upper__0,
+         sparsity_nnz_upper__1,
+         sparsity_numel,
+         sparsity_operator__equals,
+         sparsity_operator__mul,
+         sparsity_operator__nequals,
+         sparsity_operator__plus,
+         sparsity_pattern_inverse,
+         sparsity_pmult__0,
+         sparsity_pmult__1,
+         sparsity_pmult__2,
+         sparsity_pmult__3,
+         sparsity_print_compact,
+         sparsity_removeDuplicates,
+         sparsity_resize,
+         sparsity_row,
+         sparsity_rowcol,
+         sparsity_rowsSequential__0,
+         sparsity_rowsSequential__1,
+         sparsity_sanity_check__0,
+         sparsity_sanity_check__1,
+         sparsity_scalar__0,
+         sparsity_scalar__1,
+         sparsity_scc,
+         sparsity_size1,
+         sparsity_size2,
+         sparsity_size__0,
+         sparsity_size__1,
+         sparsity_spy,
+         sparsity_spy_matlab,
+         sparsity_star_coloring2__0,
+         sparsity_star_coloring2__1,
+         sparsity_star_coloring2__2,
+         sparsity_star_coloring__0,
+         sparsity_star_coloring__1,
+         sparsity_star_coloring__2,
+         sparsity_sub__0,
+         sparsity_sub__1,
+         sparsity_sub__2,
+         sparsity_sub__3,
+         sparsity_transpose__0,
+         sparsity_transpose__1,
+         sparsity_triplet__0,
+         sparsity_triplet__1,
+         sparsity_triplet__2,
+         sparsity_uni_coloring__0,
+         sparsity_uni_coloring__1,
+         sparsity_uni_coloring__2,
+         sparsity_unit,
+         sparsity_unite,
+         sparsity_upper,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+import Foreign.ForeignPtr ( newForeignPtr )
+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
+
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__0" c_casadi__Sparsity__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__CONSTRUCTOR__0
+  :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
+casadi__Sparsity__CONSTRUCTOR__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
+sparsity__0 = casadi__Sparsity__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__1" c_casadi__Sparsity__CONSTRUCTOR__1
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__CONSTRUCTOR__1
+  :: Int -> Int -> IO Sparsity
+casadi__Sparsity__CONSTRUCTOR__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__CONSTRUCTOR__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity__1 :: Int -> Int -> IO Sparsity
+sparsity__1 = casadi__Sparsity__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__2" c_casadi__Sparsity__CONSTRUCTOR__2
+  :: Ptr (Ptr StdString) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__CONSTRUCTOR__2
+  :: IO Sparsity
+casadi__Sparsity__CONSTRUCTOR__2  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__CONSTRUCTOR__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity__2 :: IO Sparsity
+sparsity__2 = casadi__Sparsity__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__3" c_casadi__Sparsity__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__CONSTRUCTOR__3
+  :: Int -> IO Sparsity
+casadi__Sparsity__CONSTRUCTOR__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__CONSTRUCTOR__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity__3 :: Int -> IO Sparsity
+sparsity__3 = casadi__Sparsity__CONSTRUCTOR__3
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__T" c_casadi__Sparsity__T
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__T
+  :: Sparsity -> IO Sparsity
+casadi__Sparsity__T x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__T errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_T :: SparsityClass a => a -> IO Sparsity
+sparsity_T x = casadi__Sparsity__T (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__add_nz" c_casadi__Sparsity__add_nz
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
+
+casadi__Sparsity__add_nz
+  :: Sparsity -> Int -> Int -> IO Int
+casadi__Sparsity__add_nz x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__add_nz errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_add_nz :: SparsityClass a => a -> Int -> Int -> IO Int
+sparsity_add_nz x = casadi__Sparsity__add_nz (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__append" c_casadi__Sparsity__append
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO ()
+
+casadi__Sparsity__append
+  :: Sparsity -> Sparsity -> IO ()
+casadi__Sparsity__append x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__append errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_append :: SparsityClass a => a -> Sparsity -> IO ()
+sparsity_append x = casadi__Sparsity__append (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__appendColumns" c_casadi__Sparsity__appendColumns
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO ()
+
+casadi__Sparsity__appendColumns
+  :: Sparsity -> Sparsity -> IO ()
+casadi__Sparsity__appendColumns x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__appendColumns errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_appendColumns :: SparsityClass a => a -> Sparsity -> IO ()
+sparsity_appendColumns x = casadi__Sparsity__appendColumns (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__band" c_casadi__Sparsity__band
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__band
+  :: Int -> Int -> IO Sparsity
+casadi__Sparsity__band x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__band errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_band :: Int -> Int -> IO Sparsity
+sparsity_band = casadi__Sparsity__band
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__banded" c_casadi__Sparsity__banded
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__banded
+  :: Int -> Int -> IO Sparsity
+casadi__Sparsity__banded x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__banded errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_banded :: Int -> Int -> IO Sparsity
+sparsity_banded = casadi__Sparsity__banded
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__btf__0" c_casadi__Sparsity__btf__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> IO CInt
+
+casadi__Sparsity__btf__0
+  :: Sparsity -> IO (Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int)
+casadi__Sparsity__btf__0 x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+  o3' <- new nullPtr
+  o4' <- new nullPtr
+  o5' <- new nullPtr
+  o6' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__btf__0 errStrPtrP x0' o1' o2' o3' o4' o5' o6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Sparsity__btf__0/c_casadi__Sparsity__btf__0" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Sparsity__btf__0/c_casadi__Sparsity__btf__0" else wrapReturn o2''
+  o3'' <- peek o3'
+  free o3'
+  o3''' <- if o3'' == nullPtr then error "swig output o3' was not set in casadi__Sparsity__btf__0/c_casadi__Sparsity__btf__0" else wrapReturn o3''
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Sparsity__btf__0/c_casadi__Sparsity__btf__0" else wrapReturn o4''
+  o5'' <- peek o5'
+  free o5'
+  o5''' <- if o5'' == nullPtr then error "swig output o5' was not set in casadi__Sparsity__btf__0/c_casadi__Sparsity__btf__0" else wrapReturn o5''
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Sparsity__btf__0/c_casadi__Sparsity__btf__0" else wrapReturn o6''
+
+  return (ret, o1''', o2''', o3''', o4''', o5''', o6''')
+
+
+
+-- classy wrapper
+sparsity_btf__0 :: SparsityClass a => a -> IO (Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int)
+sparsity_btf__0 x = casadi__Sparsity__btf__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__btf__1" c_casadi__Sparsity__btf__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> CInt -> IO CInt
+
+casadi__Sparsity__btf__1
+  :: Sparsity -> Int -> IO (Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int)
+casadi__Sparsity__btf__1 x0 x7 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+  o3' <- new nullPtr
+  o4' <- new nullPtr
+  o5' <- new nullPtr
+  o6' <- new nullPtr
+  x7' <- marshal x7
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__btf__1 errStrPtrP x0' o1' o2' o3' o4' o5' o6' x7'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Sparsity__btf__1/c_casadi__Sparsity__btf__1" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Sparsity__btf__1/c_casadi__Sparsity__btf__1" else wrapReturn o2''
+  o3'' <- peek o3'
+  free o3'
+  o3''' <- if o3'' == nullPtr then error "swig output o3' was not set in casadi__Sparsity__btf__1/c_casadi__Sparsity__btf__1" else wrapReturn o3''
+  o4'' <- peek o4'
+  free o4'
+  o4''' <- if o4'' == nullPtr then error "swig output o4' was not set in casadi__Sparsity__btf__1/c_casadi__Sparsity__btf__1" else wrapReturn o4''
+  o5'' <- peek o5'
+  free o5'
+  o5''' <- if o5'' == nullPtr then error "swig output o5' was not set in casadi__Sparsity__btf__1/c_casadi__Sparsity__btf__1" else wrapReturn o5''
+  o6'' <- peek o6'
+  free o6'
+  o6''' <- if o6'' == nullPtr then error "swig output o6' was not set in casadi__Sparsity__btf__1/c_casadi__Sparsity__btf__1" else wrapReturn o6''
+  marshalFree x7 x7'
+
+  return (ret, o1''', o2''', o3''', o4''', o5''', o6''')
+
+
+
+-- classy wrapper
+sparsity_btf__1 :: SparsityClass a => a -> Int -> IO (Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int, Vector Int)
+sparsity_btf__1 x = casadi__Sparsity__btf__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__bw_lower" c_casadi__Sparsity__bw_lower
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__bw_lower
+  :: Sparsity -> IO Int
+casadi__Sparsity__bw_lower x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__bw_lower errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_bw_lower :: SparsityClass a => a -> IO Int
+sparsity_bw_lower x = casadi__Sparsity__bw_lower (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__bw_upper" c_casadi__Sparsity__bw_upper
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__bw_upper
+  :: Sparsity -> IO Int
+casadi__Sparsity__bw_upper x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__bw_upper errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_bw_upper :: SparsityClass a => a -> IO Int
+sparsity_bw_upper x = casadi__Sparsity__bw_upper (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__colind" c_casadi__Sparsity__colind
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__colind
+  :: Sparsity -> Int -> IO Int
+casadi__Sparsity__colind x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__colind errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_colind :: SparsityClass a => a -> Int -> IO Int
+sparsity_colind x = casadi__Sparsity__colind (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__combine" c_casadi__Sparsity__combine
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__combine
+  :: Sparsity -> Sparsity -> Bool -> Bool -> IO Sparsity
+casadi__Sparsity__combine x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__combine errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_combine :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> IO Sparsity
+sparsity_combine x = casadi__Sparsity__combine (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__compress" c_casadi__Sparsity__compress
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__compress
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__compress x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__compress errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_compress :: SparsityClass a => a -> IO (Vector Int)
+sparsity_compress x = casadi__Sparsity__compress (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__compressed" c_casadi__Sparsity__compressed
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__compressed
+  :: Vector Int -> IO Sparsity
+casadi__Sparsity__compressed x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__compressed errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_compressed :: Vector Int -> IO Sparsity
+sparsity_compressed = casadi__Sparsity__compressed
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__dense__0" c_casadi__Sparsity__dense__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__dense__0
+  :: (Int, Int) -> IO Sparsity
+casadi__Sparsity__dense__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__dense__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_dense__0 :: (Int, Int) -> IO Sparsity
+sparsity_dense__0 = casadi__Sparsity__dense__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__dense__1" c_casadi__Sparsity__dense__1
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__dense__1
+  :: Int -> IO Sparsity
+casadi__Sparsity__dense__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__dense__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_dense__1 :: Int -> IO Sparsity
+sparsity_dense__1 = casadi__Sparsity__dense__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__dense__2" c_casadi__Sparsity__dense__2
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__dense__2
+  :: Int -> Int -> IO Sparsity
+casadi__Sparsity__dense__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__dense__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_dense__2 :: Int -> Int -> IO Sparsity
+sparsity_dense__2 = casadi__Sparsity__dense__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__dfs" c_casadi__Sparsity__dfs
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
+
+casadi__Sparsity__dfs
+  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int
+casadi__Sparsity__dfs x0 x1 x2 x3 x4 x5 x6 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+  x6' <- marshal x6
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__dfs errStrPtrP x0' x1' x2' x3' x4' x5' x6'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+  marshalFree x6 x6'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_dfs :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int
+sparsity_dfs x = casadi__Sparsity__dfs (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__diag__0" c_casadi__Sparsity__diag__0
+  :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__diag__0
+  :: (Int, Int) -> IO Sparsity
+casadi__Sparsity__diag__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__diag__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_diag__0 :: (Int, Int) -> IO Sparsity
+sparsity_diag__0 = casadi__Sparsity__diag__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__diag__1" c_casadi__Sparsity__diag__1
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__diag__1
+  :: Int -> Int -> IO Sparsity
+casadi__Sparsity__diag__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__diag__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_diag__1 :: Int -> Int -> IO Sparsity
+sparsity_diag__1 = casadi__Sparsity__diag__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__diag__2" c_casadi__Sparsity__diag__2
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__diag__2
+  :: Int -> IO Sparsity
+casadi__Sparsity__diag__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__diag__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_diag__2 :: Int -> IO Sparsity
+sparsity_diag__2 = casadi__Sparsity__diag__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__dim" c_casadi__Sparsity__dim
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr StdString)
+
+casadi__Sparsity__dim
+  :: Sparsity -> IO String
+casadi__Sparsity__dim x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__dim errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_dim :: SparsityClass a => a -> IO String
+sparsity_dim x = casadi__Sparsity__dim (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__enlarge__0" c_casadi__Sparsity__enlarge__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+
+casadi__Sparsity__enlarge__0
+  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+casadi__Sparsity__enlarge__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_enlarge__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
+sparsity_enlarge__0 x = casadi__Sparsity__enlarge__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__enlarge__1" c_casadi__Sparsity__enlarge__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__Sparsity__enlarge__1
+  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+casadi__Sparsity__enlarge__1 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_enlarge__1 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
+sparsity_enlarge__1 x = casadi__Sparsity__enlarge__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__0" c_casadi__Sparsity__enlargeColumns__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO ()
+
+casadi__Sparsity__enlargeColumns__0
+  :: Sparsity -> Int -> Vector Int -> IO ()
+casadi__Sparsity__enlargeColumns__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__enlargeColumns__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_enlargeColumns__0 :: SparsityClass a => a -> Int -> Vector Int -> IO ()
+sparsity_enlargeColumns__0 x = casadi__Sparsity__enlargeColumns__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__1" c_casadi__Sparsity__enlargeColumns__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__Sparsity__enlargeColumns__1
+  :: Sparsity -> Int -> Vector Int -> Bool -> IO ()
+casadi__Sparsity__enlargeColumns__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__enlargeColumns__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_enlargeColumns__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO ()
+sparsity_enlargeColumns__1 x = casadi__Sparsity__enlargeColumns__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__enlargeRows__0" c_casadi__Sparsity__enlargeRows__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO ()
+
+casadi__Sparsity__enlargeRows__0
+  :: Sparsity -> Int -> Vector Int -> IO ()
+casadi__Sparsity__enlargeRows__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__enlargeRows__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_enlargeRows__0 :: SparsityClass a => a -> Int -> Vector Int -> IO ()
+sparsity_enlargeRows__0 x = casadi__Sparsity__enlargeRows__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__enlargeRows__1" c_casadi__Sparsity__enlargeRows__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO ()
+
+casadi__Sparsity__enlargeRows__1
+  :: Sparsity -> Int -> Vector Int -> Bool -> IO ()
+casadi__Sparsity__enlargeRows__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__enlargeRows__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_enlargeRows__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO ()
+sparsity_enlargeRows__1 x = casadi__Sparsity__enlargeRows__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__erase__0" c_casadi__Sparsity__erase__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__erase__0
+  :: Sparsity -> Vector Int -> IO (Vector Int)
+casadi__Sparsity__erase__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__erase__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_erase__0 :: SparsityClass a => a -> Vector Int -> IO (Vector Int)
+sparsity_erase__0 x = casadi__Sparsity__erase__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__erase__1" c_casadi__Sparsity__erase__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__erase__1
+  :: Sparsity -> Vector Int -> Bool -> IO (Vector Int)
+casadi__Sparsity__erase__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__erase__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_erase__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO (Vector Int)
+sparsity_erase__1 x = casadi__Sparsity__erase__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__erase__2" c_casadi__Sparsity__erase__2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__erase__2
+  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int)
+casadi__Sparsity__erase__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__erase__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_erase__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
+sparsity_erase__2 x = casadi__Sparsity__erase__2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__erase__3" c_casadi__Sparsity__erase__3
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__erase__3
+  :: Sparsity -> Vector Int -> Vector Int -> Bool -> IO (Vector Int)
+casadi__Sparsity__erase__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__erase__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_erase__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Bool -> IO (Vector Int)
+sparsity_erase__3 x = casadi__Sparsity__erase__3 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__etree__0" c_casadi__Sparsity__etree__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__etree__0
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__etree__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__etree__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_etree__0 :: SparsityClass a => a -> IO (Vector Int)
+sparsity_etree__0 x = casadi__Sparsity__etree__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__etree__1" c_casadi__Sparsity__etree__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__etree__1
+  :: Sparsity -> Bool -> IO (Vector Int)
+casadi__Sparsity__etree__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__etree__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_etree__1 :: SparsityClass a => a -> Bool -> IO (Vector Int)
+sparsity_etree__1 x = casadi__Sparsity__etree__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__find__0" c_casadi__Sparsity__find__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__find__0
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__find__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__find__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_find__0 :: SparsityClass a => a -> IO (Vector Int)
+sparsity_find__0 x = casadi__Sparsity__find__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__find__1" c_casadi__Sparsity__find__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__find__1
+  :: Sparsity -> Bool -> IO (Vector Int)
+casadi__Sparsity__find__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__find__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_find__1 :: SparsityClass a => a -> Bool -> IO (Vector Int)
+sparsity_find__1 x = casadi__Sparsity__find__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_ccs" c_casadi__Sparsity__get_ccs
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> IO ()
+
+casadi__Sparsity__get_ccs
+  :: Sparsity -> IO (Vector Int, Vector Int)
+casadi__Sparsity__get_ccs x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_ccs errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Sparsity__get_ccs/c_casadi__Sparsity__get_ccs" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Sparsity__get_ccs/c_casadi__Sparsity__get_ccs" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+-- classy wrapper
+sparsity_get_ccs :: SparsityClass a => a -> IO (Vector Int, Vector Int)
+sparsity_get_ccs x = casadi__Sparsity__get_ccs (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_col" c_casadi__Sparsity__get_col
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__get_col
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__get_col x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_col errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_get_col :: SparsityClass a => a -> IO (Vector Int)
+sparsity_get_col x = casadi__Sparsity__get_col (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_colind" c_casadi__Sparsity__get_colind
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__get_colind
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__get_colind x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_colind errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_get_colind :: SparsityClass a => a -> IO (Vector Int)
+sparsity_get_colind x = casadi__Sparsity__get_colind (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_crs" c_casadi__Sparsity__get_crs
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> IO ()
+
+casadi__Sparsity__get_crs
+  :: Sparsity -> IO (Vector Int, Vector Int)
+casadi__Sparsity__get_crs x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_crs errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Sparsity__get_crs/c_casadi__Sparsity__get_crs" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Sparsity__get_crs/c_casadi__Sparsity__get_crs" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+-- classy wrapper
+sparsity_get_crs :: SparsityClass a => a -> IO (Vector Int, Vector Int)
+sparsity_get_crs x = casadi__Sparsity__get_crs (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_diag" c_casadi__Sparsity__get_diag
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__get_diag
+  :: Sparsity -> IO (Sparsity, Vector Int)
+casadi__Sparsity__get_diag x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_diag errStrPtrP x0' o1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Sparsity__get_diag/c_casadi__Sparsity__get_diag" else wrapReturn o1''
+
+  return (ret, o1''')
+
+
+
+-- classy wrapper
+sparsity_get_diag :: SparsityClass a => a -> IO (Sparsity, Vector Int)
+sparsity_get_diag x = casadi__Sparsity__get_diag (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_lower" c_casadi__Sparsity__get_lower
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__get_lower
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__get_lower x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_lower errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_get_lower :: SparsityClass a => a -> IO (Vector Int)
+sparsity_get_lower x = casadi__Sparsity__get_lower (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_nz__0" c_casadi__Sparsity__get_nz__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
+
+casadi__Sparsity__get_nz__0
+  :: Sparsity -> Vector Int -> IO ()
+casadi__Sparsity__get_nz__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_nz__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_get_nz__0 :: SparsityClass a => a -> Vector Int -> IO ()
+sparsity_get_nz__0 x = casadi__Sparsity__get_nz__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_nz__1" c_casadi__Sparsity__get_nz__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__get_nz__1
+  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int)
+casadi__Sparsity__get_nz__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_nz__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_get_nz__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
+sparsity_get_nz__1 x = casadi__Sparsity__get_nz__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_nz__2" c_casadi__Sparsity__get_nz__2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
+
+casadi__Sparsity__get_nz__2
+  :: Sparsity -> Int -> Int -> IO Int
+casadi__Sparsity__get_nz__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_nz__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_get_nz__2 :: SparsityClass a => a -> Int -> Int -> IO Int
+sparsity_get_nz__2 x = casadi__Sparsity__get_nz__2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_row" c_casadi__Sparsity__get_row
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__get_row
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__get_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_get_row :: SparsityClass a => a -> IO (Vector Int)
+sparsity_get_row x = casadi__Sparsity__get_row (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_triplet" c_casadi__Sparsity__get_triplet
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> IO ()
+
+casadi__Sparsity__get_triplet
+  :: Sparsity -> IO (Vector Int, Vector Int)
+casadi__Sparsity__get_triplet x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_triplet errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Sparsity__get_triplet/c_casadi__Sparsity__get_triplet" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Sparsity__get_triplet/c_casadi__Sparsity__get_triplet" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+-- classy wrapper
+sparsity_get_triplet :: SparsityClass a => a -> IO (Vector Int, Vector Int)
+sparsity_get_triplet x = casadi__Sparsity__get_triplet (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__get_upper" c_casadi__Sparsity__get_upper
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__get_upper
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__get_upper x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__get_upper errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_get_upper :: SparsityClass a => a -> IO (Vector Int)
+sparsity_get_upper x = casadi__Sparsity__get_upper (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__has_nz" c_casadi__Sparsity__has_nz
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
+
+casadi__Sparsity__has_nz
+  :: Sparsity -> Int -> Int -> IO Bool
+casadi__Sparsity__has_nz x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__has_nz errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_has_nz :: SparsityClass a => a -> Int -> Int -> IO Bool
+sparsity_has_nz x = casadi__Sparsity__has_nz (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__hash" c_casadi__Sparsity__hash
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CSize
+
+casadi__Sparsity__hash
+  :: Sparsity -> IO CSize
+casadi__Sparsity__hash x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__hash errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_hash :: SparsityClass a => a -> IO CSize
+sparsity_hash x = casadi__Sparsity__hash (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__intersect" c_casadi__Sparsity__intersect
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__intersect
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi__Sparsity__intersect x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__intersect errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_intersect :: SparsityClass a => a -> Sparsity -> IO Sparsity
+sparsity_intersect x = casadi__Sparsity__intersect (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__isReshape" c_casadi__Sparsity__isReshape
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__isReshape
+  :: Sparsity -> Sparsity -> IO Bool
+casadi__Sparsity__isReshape x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__isReshape errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_isReshape :: SparsityClass a => a -> Sparsity -> IO Bool
+sparsity_isReshape x = casadi__Sparsity__isReshape (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_column" c_casadi__Sparsity__is_column
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_column
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_column x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_column errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_column :: SparsityClass a => a -> IO Bool
+sparsity_is_column x = casadi__Sparsity__is_column (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_dense" c_casadi__Sparsity__is_dense
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_dense
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_dense x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_dense errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_dense :: SparsityClass a => a -> IO Bool
+sparsity_is_dense x = casadi__Sparsity__is_dense (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_diag" c_casadi__Sparsity__is_diag
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_diag
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_diag x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_diag errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_diag :: SparsityClass a => a -> IO Bool
+sparsity_is_diag x = casadi__Sparsity__is_diag (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_empty__0" c_casadi__Sparsity__is_empty__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_empty__0
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_empty__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_empty__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_empty__0 :: SparsityClass a => a -> IO Bool
+sparsity_is_empty__0 x = casadi__Sparsity__is_empty__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_empty__1" c_casadi__Sparsity__is_empty__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__is_empty__1
+  :: Sparsity -> Bool -> IO Bool
+casadi__Sparsity__is_empty__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_empty__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_empty__1 :: SparsityClass a => a -> Bool -> IO Bool
+sparsity_is_empty__1 x = casadi__Sparsity__is_empty__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_equal__0" c_casadi__Sparsity__is_equal__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
+
+casadi__Sparsity__is_equal__0
+  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO Bool
+casadi__Sparsity__is_equal__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_equal__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_equal__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO Bool
+sparsity_is_equal__0 x = casadi__Sparsity__is_equal__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_equal__1" c_casadi__Sparsity__is_equal__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_equal__1
+  :: Sparsity -> Sparsity -> IO Bool
+casadi__Sparsity__is_equal__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_equal__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_equal__1 :: SparsityClass a => a -> Sparsity -> IO Bool
+sparsity_is_equal__1 x = casadi__Sparsity__is_equal__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_row" c_casadi__Sparsity__is_row
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_row
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_row x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_row errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_row :: SparsityClass a => a -> IO Bool
+sparsity_is_row x = casadi__Sparsity__is_row (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_scalar__0" c_casadi__Sparsity__is_scalar__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_scalar__0
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_scalar__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_scalar__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_scalar__0 :: SparsityClass a => a -> IO Bool
+sparsity_is_scalar__0 x = casadi__Sparsity__is_scalar__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_scalar__1" c_casadi__Sparsity__is_scalar__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__is_scalar__1
+  :: Sparsity -> Bool -> IO Bool
+casadi__Sparsity__is_scalar__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_scalar__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_scalar__1 :: SparsityClass a => a -> Bool -> IO Bool
+sparsity_is_scalar__1 x = casadi__Sparsity__is_scalar__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_singular" c_casadi__Sparsity__is_singular
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_singular
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_singular x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_singular errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_singular :: SparsityClass a => a -> IO Bool
+sparsity_is_singular x = casadi__Sparsity__is_singular (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_square" c_casadi__Sparsity__is_square
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_square
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_square x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_square errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_square :: SparsityClass a => a -> IO Bool
+sparsity_is_square x = casadi__Sparsity__is_square (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_symmetric" c_casadi__Sparsity__is_symmetric
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_symmetric
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_symmetric x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_symmetric errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_symmetric :: SparsityClass a => a -> IO Bool
+sparsity_is_symmetric x = casadi__Sparsity__is_symmetric (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_transpose" c_casadi__Sparsity__is_transpose
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_transpose
+  :: Sparsity -> Sparsity -> IO Bool
+casadi__Sparsity__is_transpose x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_transpose errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_transpose :: SparsityClass a => a -> Sparsity -> IO Bool
+sparsity_is_transpose x = casadi__Sparsity__is_transpose (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_tril" c_casadi__Sparsity__is_tril
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_tril
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_tril x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_tril errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_tril :: SparsityClass a => a -> IO Bool
+sparsity_is_tril x = casadi__Sparsity__is_tril (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_triu" c_casadi__Sparsity__is_triu
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_triu
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_triu x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_triu errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_triu :: SparsityClass a => a -> IO Bool
+sparsity_is_triu x = casadi__Sparsity__is_triu (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__is_vector" c_casadi__Sparsity__is_vector
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__is_vector
+  :: Sparsity -> IO Bool
+casadi__Sparsity__is_vector x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__is_vector errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_is_vector :: SparsityClass a => a -> IO Bool
+sparsity_is_vector x = casadi__Sparsity__is_vector (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__largest_first" c_casadi__Sparsity__largest_first
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
+
+casadi__Sparsity__largest_first
+  :: Sparsity -> IO (Vector Int)
+casadi__Sparsity__largest_first x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__largest_first errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_largest_first :: SparsityClass a => a -> IO (Vector Int)
+sparsity_largest_first x = casadi__Sparsity__largest_first (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__lower" c_casadi__Sparsity__lower
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__lower
+  :: Int -> IO Sparsity
+casadi__Sparsity__lower x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__lower errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_lower :: Int -> IO Sparsity
+sparsity_lower = casadi__Sparsity__lower
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__makeDense" c_casadi__Sparsity__makeDense
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__makeDense
+  :: Sparsity -> Vector Int -> IO Sparsity
+casadi__Sparsity__makeDense x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__makeDense errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_makeDense :: SparsityClass a => a -> Vector Int -> IO Sparsity
+sparsity_makeDense x = casadi__Sparsity__makeDense (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__nnz" c_casadi__Sparsity__nnz
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__nnz
+  :: Sparsity -> IO Int
+casadi__Sparsity__nnz x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__nnz errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_nnz :: SparsityClass a => a -> IO Int
+sparsity_nnz x = casadi__Sparsity__nnz (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__nnz_diag" c_casadi__Sparsity__nnz_diag
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__nnz_diag
+  :: Sparsity -> IO Int
+casadi__Sparsity__nnz_diag x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__nnz_diag errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_nnz_diag :: SparsityClass a => a -> IO Int
+sparsity_nnz_diag x = casadi__Sparsity__nnz_diag (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__nnz_lower__0" c_casadi__Sparsity__nnz_lower__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__nnz_lower__0
+  :: Sparsity -> IO Int
+casadi__Sparsity__nnz_lower__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__nnz_lower__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_nnz_lower__0 :: SparsityClass a => a -> IO Int
+sparsity_nnz_lower__0 x = casadi__Sparsity__nnz_lower__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__nnz_lower__1" c_casadi__Sparsity__nnz_lower__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__nnz_lower__1
+  :: Sparsity -> Bool -> IO Int
+casadi__Sparsity__nnz_lower__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__nnz_lower__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_nnz_lower__1 :: SparsityClass a => a -> Bool -> IO Int
+sparsity_nnz_lower__1 x = casadi__Sparsity__nnz_lower__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__nnz_upper__0" c_casadi__Sparsity__nnz_upper__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__nnz_upper__0
+  :: Sparsity -> IO Int
+casadi__Sparsity__nnz_upper__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__nnz_upper__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_nnz_upper__0 :: SparsityClass a => a -> IO Int
+sparsity_nnz_upper__0 x = casadi__Sparsity__nnz_upper__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__nnz_upper__1" c_casadi__Sparsity__nnz_upper__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__nnz_upper__1
+  :: Sparsity -> Bool -> IO Int
+casadi__Sparsity__nnz_upper__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__nnz_upper__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_nnz_upper__1 :: SparsityClass a => a -> Bool -> IO Int
+sparsity_nnz_upper__1 x = casadi__Sparsity__nnz_upper__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__numel" c_casadi__Sparsity__numel
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__numel
+  :: Sparsity -> IO Int
+casadi__Sparsity__numel x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__numel errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_numel :: SparsityClass a => a -> IO Int
+sparsity_numel x = casadi__Sparsity__numel (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__operator__nequals" c_casadi__Sparsity__operator__nequals
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__operator__nequals
+  :: Sparsity -> Sparsity -> IO Bool
+casadi__Sparsity__operator__nequals x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__operator__nequals errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_operator__nequals :: SparsityClass a => a -> Sparsity -> IO Bool
+sparsity_operator__nequals x = casadi__Sparsity__operator__nequals (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__operator__mul" c_casadi__Sparsity__operator__mul
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__operator__mul
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi__Sparsity__operator__mul x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__operator__mul errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_operator__mul :: SparsityClass a => a -> Sparsity -> IO Sparsity
+sparsity_operator__mul x = casadi__Sparsity__operator__mul (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__operator__plus" c_casadi__Sparsity__operator__plus
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__operator__plus
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi__Sparsity__operator__plus x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__operator__plus errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_operator__plus :: SparsityClass a => a -> Sparsity -> IO Sparsity
+sparsity_operator__plus x = casadi__Sparsity__operator__plus (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__operator__equals" c_casadi__Sparsity__operator__equals
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__operator__equals
+  :: Sparsity -> Sparsity -> IO Bool
+casadi__Sparsity__operator__equals x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__operator__equals errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_operator__equals :: SparsityClass a => a -> Sparsity -> IO Bool
+sparsity_operator__equals x = casadi__Sparsity__operator__equals (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__pattern_inverse" c_casadi__Sparsity__pattern_inverse
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__pattern_inverse
+  :: Sparsity -> IO Sparsity
+casadi__Sparsity__pattern_inverse x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__pattern_inverse errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_pattern_inverse :: SparsityClass a => a -> IO Sparsity
+sparsity_pattern_inverse x = casadi__Sparsity__pattern_inverse (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__pmult__0" c_casadi__Sparsity__pmult__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__pmult__0
+  :: Sparsity -> Vector Int -> IO Sparsity
+casadi__Sparsity__pmult__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__pmult__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_pmult__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity
+sparsity_pmult__0 x = casadi__Sparsity__pmult__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__pmult__1" c_casadi__Sparsity__pmult__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__pmult__1
+  :: Sparsity -> Vector Int -> Bool -> IO Sparsity
+casadi__Sparsity__pmult__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__pmult__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_pmult__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity
+sparsity_pmult__1 x = casadi__Sparsity__pmult__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__pmult__2" c_casadi__Sparsity__pmult__2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__pmult__2
+  :: Sparsity -> Vector Int -> Bool -> Bool -> IO Sparsity
+casadi__Sparsity__pmult__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__pmult__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_pmult__2 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> IO Sparsity
+sparsity_pmult__2 x = casadi__Sparsity__pmult__2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__pmult__3" c_casadi__Sparsity__pmult__3
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__pmult__3
+  :: Sparsity -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity
+casadi__Sparsity__pmult__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__pmult__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_pmult__3 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity
+sparsity_pmult__3 x = casadi__Sparsity__pmult__3 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__print_compact" c_casadi__Sparsity__print_compact
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
+
+casadi__Sparsity__print_compact
+  :: Sparsity -> IO ()
+casadi__Sparsity__print_compact x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__print_compact errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_print_compact :: SparsityClass a => a -> IO ()
+sparsity_print_compact x = casadi__Sparsity__print_compact (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__removeDuplicates" c_casadi__Sparsity__removeDuplicates
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
+
+casadi__Sparsity__removeDuplicates
+  :: Sparsity -> Vector Int -> IO ()
+casadi__Sparsity__removeDuplicates x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__removeDuplicates errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_removeDuplicates :: SparsityClass a => a -> Vector Int -> IO ()
+sparsity_removeDuplicates x = casadi__Sparsity__removeDuplicates (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__resize" c_casadi__Sparsity__resize
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO ()
+
+casadi__Sparsity__resize
+  :: Sparsity -> Int -> Int -> IO ()
+casadi__Sparsity__resize x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__resize errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_resize :: SparsityClass a => a -> Int -> Int -> IO ()
+sparsity_resize x = casadi__Sparsity__resize (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__row" c_casadi__Sparsity__row
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__row
+  :: Sparsity -> Int -> IO Int
+casadi__Sparsity__row x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__row errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_row :: SparsityClass a => a -> Int -> IO Int
+sparsity_row x = casadi__Sparsity__row (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__rowcol" c_casadi__Sparsity__rowcol
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__rowcol
+  :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity
+casadi__Sparsity__rowcol x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__rowcol errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_rowcol :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity
+sparsity_rowcol = casadi__Sparsity__rowcol
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__rowsSequential__0" c_casadi__Sparsity__rowsSequential__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__rowsSequential__0
+  :: Sparsity -> IO Bool
+casadi__Sparsity__rowsSequential__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__rowsSequential__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_rowsSequential__0 :: SparsityClass a => a -> IO Bool
+sparsity_rowsSequential__0 x = casadi__Sparsity__rowsSequential__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__rowsSequential__1" c_casadi__Sparsity__rowsSequential__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__rowsSequential__1
+  :: Sparsity -> Bool -> IO Bool
+casadi__Sparsity__rowsSequential__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__rowsSequential__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_rowsSequential__1 :: SparsityClass a => a -> Bool -> IO Bool
+sparsity_rowsSequential__1 x = casadi__Sparsity__rowsSequential__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__sanity_check__0" c_casadi__Sparsity__sanity_check__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
+
+casadi__Sparsity__sanity_check__0
+  :: Sparsity -> IO ()
+casadi__Sparsity__sanity_check__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__sanity_check__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_sanity_check__0 :: SparsityClass a => a -> IO ()
+sparsity_sanity_check__0 x = casadi__Sparsity__sanity_check__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__sanity_check__1" c_casadi__Sparsity__sanity_check__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO ()
+
+casadi__Sparsity__sanity_check__1
+  :: Sparsity -> Bool -> IO ()
+casadi__Sparsity__sanity_check__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__sanity_check__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_sanity_check__1 :: SparsityClass a => a -> Bool -> IO ()
+sparsity_sanity_check__1 x = casadi__Sparsity__sanity_check__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__scalar__0" c_casadi__Sparsity__scalar__0
+  :: Ptr (Ptr StdString) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__scalar__0
+  :: IO Sparsity
+casadi__Sparsity__scalar__0  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__scalar__0 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_scalar__0 :: IO Sparsity
+sparsity_scalar__0 = casadi__Sparsity__scalar__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__scalar__1" c_casadi__Sparsity__scalar__1
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__scalar__1
+  :: Bool -> IO Sparsity
+casadi__Sparsity__scalar__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__scalar__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_scalar__1 :: Bool -> IO Sparsity
+sparsity_scalar__1 = casadi__Sparsity__scalar__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__scc" c_casadi__Sparsity__scc
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> Ptr (Ptr (StdVec CInt)) -> IO CInt
+
+casadi__Sparsity__scc
+  :: Sparsity -> IO (Int, Vector Int, Vector Int)
+casadi__Sparsity__scc x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__scc errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in casadi__Sparsity__scc/c_casadi__Sparsity__scc" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in casadi__Sparsity__scc/c_casadi__Sparsity__scc" else wrapReturn o2''
+
+  return (ret, o1''', o2''')
+
+
+
+-- classy wrapper
+sparsity_scc :: SparsityClass a => a -> IO (Int, Vector Int, Vector Int)
+sparsity_scc x = casadi__Sparsity__scc (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__size__0" c_casadi__Sparsity__size__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
+
+casadi__Sparsity__size__0
+  :: Sparsity -> Int -> IO Int
+casadi__Sparsity__size__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__size__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_size__0 :: SparsityClass a => a -> Int -> IO Int
+sparsity_size__0 x = casadi__Sparsity__size__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__size__1" c_casadi__Sparsity__size__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdPair CInt CInt))
+
+casadi__Sparsity__size__1
+  :: Sparsity -> IO (Int, Int)
+casadi__Sparsity__size__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__size__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_size__1 :: SparsityClass a => a -> IO (Int, Int)
+sparsity_size__1 x = casadi__Sparsity__size__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__size1" c_casadi__Sparsity__size1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__size1
+  :: Sparsity -> IO Int
+casadi__Sparsity__size1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__size1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_size1 :: SparsityClass a => a -> IO Int
+sparsity_size1 x = casadi__Sparsity__size1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__size2" c_casadi__Sparsity__size2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi__Sparsity__size2
+  :: Sparsity -> IO Int
+casadi__Sparsity__size2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__size2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_size2 :: SparsityClass a => a -> IO Int
+sparsity_size2 x = casadi__Sparsity__size2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__spy" c_casadi__Sparsity__spy
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
+
+casadi__Sparsity__spy
+  :: Sparsity -> IO ()
+casadi__Sparsity__spy x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__spy errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_spy :: SparsityClass a => a -> IO ()
+sparsity_spy x = casadi__Sparsity__spy (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__spy_matlab" c_casadi__Sparsity__spy_matlab
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr StdString -> IO ()
+
+casadi__Sparsity__spy_matlab
+  :: Sparsity -> String -> IO ()
+casadi__Sparsity__spy_matlab x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__spy_matlab errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+-- classy wrapper
+sparsity_spy_matlab :: SparsityClass a => a -> String -> IO ()
+sparsity_spy_matlab x = casadi__Sparsity__spy_matlab (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__star_coloring__0" c_casadi__Sparsity__star_coloring__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__star_coloring__0
+  :: Sparsity -> IO Sparsity
+casadi__Sparsity__star_coloring__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__star_coloring__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_star_coloring__0 :: SparsityClass a => a -> IO Sparsity
+sparsity_star_coloring__0 x = casadi__Sparsity__star_coloring__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__star_coloring__1" c_casadi__Sparsity__star_coloring__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__star_coloring__1
+  :: Sparsity -> Int -> IO Sparsity
+casadi__Sparsity__star_coloring__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__star_coloring__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_star_coloring__1 :: SparsityClass a => a -> Int -> IO Sparsity
+sparsity_star_coloring__1 x = casadi__Sparsity__star_coloring__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__star_coloring__2" c_casadi__Sparsity__star_coloring__2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__star_coloring__2
+  :: Sparsity -> Int -> Int -> IO Sparsity
+casadi__Sparsity__star_coloring__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__star_coloring__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_star_coloring__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
+sparsity_star_coloring__2 x = casadi__Sparsity__star_coloring__2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__star_coloring2__0" c_casadi__Sparsity__star_coloring2__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__star_coloring2__0
+  :: Sparsity -> IO Sparsity
+casadi__Sparsity__star_coloring2__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__star_coloring2__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_star_coloring2__0 :: SparsityClass a => a -> IO Sparsity
+sparsity_star_coloring2__0 x = casadi__Sparsity__star_coloring2__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__star_coloring2__1" c_casadi__Sparsity__star_coloring2__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__star_coloring2__1
+  :: Sparsity -> Int -> IO Sparsity
+casadi__Sparsity__star_coloring2__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__star_coloring2__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_star_coloring2__1 :: SparsityClass a => a -> Int -> IO Sparsity
+sparsity_star_coloring2__1 x = casadi__Sparsity__star_coloring2__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__star_coloring2__2" c_casadi__Sparsity__star_coloring2__2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__star_coloring2__2
+  :: Sparsity -> Int -> Int -> IO Sparsity
+casadi__Sparsity__star_coloring2__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__star_coloring2__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_star_coloring2__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
+sparsity_star_coloring2__2 x = casadi__Sparsity__star_coloring2__2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__sub__0" c_casadi__Sparsity__sub__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__sub__0
+  :: Sparsity -> Vector Int -> Sparsity -> IO (Sparsity, Vector Int)
+casadi__Sparsity__sub__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  o3' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__sub__0 errStrPtrP x0' x1' x2' o3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  o3'' <- peek o3'
+  free o3'
+  o3''' <- if o3'' == nullPtr then error "swig output o3' was not set in casadi__Sparsity__sub__0/c_casadi__Sparsity__sub__0" else wrapReturn o3''
+
+  return (ret, o3''')
+
+
+
+-- classy wrapper
+sparsity_sub__0 :: SparsityClass a => a -> Vector Int -> Sparsity -> IO (Sparsity, Vector Int)
+sparsity_sub__0 x = casadi__Sparsity__sub__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__sub__1" c_casadi__Sparsity__sub__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (Ptr (StdVec CInt)) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__sub__1
+  :: Sparsity -> Vector Int -> Sparsity -> Bool -> IO (Sparsity, Vector Int)
+casadi__Sparsity__sub__1 x0 x1 x2 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  o3' <- new nullPtr
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__sub__1 errStrPtrP x0' x1' x2' o3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  o3'' <- peek o3'
+  free o3'
+  o3''' <- if o3'' == nullPtr then error "swig output o3' was not set in casadi__Sparsity__sub__1/c_casadi__Sparsity__sub__1" else wrapReturn o3''
+  marshalFree x4 x4'
+
+  return (ret, o3''')
+
+
+
+-- classy wrapper
+sparsity_sub__1 :: SparsityClass a => a -> Vector Int -> Sparsity -> Bool -> IO (Sparsity, Vector Int)
+sparsity_sub__1 x = casadi__Sparsity__sub__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__sub__2" c_casadi__Sparsity__sub__2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (Ptr (StdVec CInt)) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__sub__2
+  :: Sparsity -> Vector Int -> Vector Int -> IO (Sparsity, Vector Int)
+casadi__Sparsity__sub__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  o3' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__sub__2 errStrPtrP x0' x1' x2' o3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  o3'' <- peek o3'
+  free o3'
+  o3''' <- if o3'' == nullPtr then error "swig output o3' was not set in casadi__Sparsity__sub__2/c_casadi__Sparsity__sub__2" else wrapReturn o3''
+
+  return (ret, o3''')
+
+
+
+-- classy wrapper
+sparsity_sub__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Sparsity, Vector Int)
+sparsity_sub__2 x = casadi__Sparsity__sub__2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__sub__3" c_casadi__Sparsity__sub__3
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (Ptr (StdVec CInt)) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__sub__3
+  :: Sparsity -> Vector Int -> Vector Int -> Bool -> IO (Sparsity, Vector Int)
+casadi__Sparsity__sub__3 x0 x1 x2 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  o3' <- new nullPtr
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__sub__3 errStrPtrP x0' x1' x2' o3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  o3'' <- peek o3'
+  free o3'
+  o3''' <- if o3'' == nullPtr then error "swig output o3' was not set in casadi__Sparsity__sub__3/c_casadi__Sparsity__sub__3" else wrapReturn o3''
+  marshalFree x4 x4'
+
+  return (ret, o3''')
+
+
+
+-- classy wrapper
+sparsity_sub__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Bool -> IO (Sparsity, Vector Int)
+sparsity_sub__3 x = casadi__Sparsity__sub__3 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__transpose__0" c_casadi__Sparsity__transpose__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__transpose__0
+  :: Sparsity -> Vector Int -> IO Sparsity
+casadi__Sparsity__transpose__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__transpose__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_transpose__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity
+sparsity_transpose__0 x = casadi__Sparsity__transpose__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__transpose__1" c_casadi__Sparsity__transpose__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__transpose__1
+  :: Sparsity -> Vector Int -> Bool -> IO Sparsity
+casadi__Sparsity__transpose__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__transpose__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_transpose__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity
+sparsity_transpose__1 x = casadi__Sparsity__transpose__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__triplet__0" c_casadi__Sparsity__triplet__0
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__triplet__0
+  :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
+casadi__Sparsity__triplet__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__triplet__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_triplet__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
+sparsity_triplet__0 = casadi__Sparsity__triplet__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__triplet__1" c_casadi__Sparsity__triplet__1
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
+
+casadi__Sparsity__triplet__1
+  :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
+casadi__Sparsity__triplet__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_triplet__1 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
+sparsity_triplet__1 = casadi__Sparsity__triplet__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__triplet__2" c_casadi__Sparsity__triplet__2
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__triplet__2
+  :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
+casadi__Sparsity__triplet__2 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__triplet__2 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_triplet__2 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
+sparsity_triplet__2 = casadi__Sparsity__triplet__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__uni_coloring__0" c_casadi__Sparsity__uni_coloring__0
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__uni_coloring__0
+  :: Sparsity -> IO Sparsity
+casadi__Sparsity__uni_coloring__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__uni_coloring__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_uni_coloring__0 :: SparsityClass a => a -> IO Sparsity
+sparsity_uni_coloring__0 x = casadi__Sparsity__uni_coloring__0 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__uni_coloring__1" c_casadi__Sparsity__uni_coloring__1
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__uni_coloring__1
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi__Sparsity__uni_coloring__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__uni_coloring__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_uni_coloring__1 :: SparsityClass a => a -> Sparsity -> IO Sparsity
+sparsity_uni_coloring__1 x = casadi__Sparsity__uni_coloring__1 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__uni_coloring__2" c_casadi__Sparsity__uni_coloring__2
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__uni_coloring__2
+  :: Sparsity -> Sparsity -> Int -> IO Sparsity
+casadi__Sparsity__uni_coloring__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__uni_coloring__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_uni_coloring__2 :: SparsityClass a => a -> Sparsity -> Int -> IO Sparsity
+sparsity_uni_coloring__2 x = casadi__Sparsity__uni_coloring__2 (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__unit" c_casadi__Sparsity__unit
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__unit
+  :: Int -> Int -> IO Sparsity
+casadi__Sparsity__unit x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__unit errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_unit :: Int -> Int -> IO Sparsity
+sparsity_unit = casadi__Sparsity__unit
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__unite" c_casadi__Sparsity__unite
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi__Sparsity__unite
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi__Sparsity__unite x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__unite errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_unite :: SparsityClass a => a -> Sparsity -> IO Sparsity
+sparsity_unite x = casadi__Sparsity__unite (castSparsity x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Sparsity__upper" c_casadi__Sparsity__upper
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
+
+casadi__Sparsity__upper
+  :: Int -> IO Sparsity
+casadi__Sparsity__upper x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Sparsity__upper errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+-- classy wrapper
+sparsity_upper :: Int -> IO Sparsity
+sparsity_upper = casadi__Sparsity__upper
 
diff --git a/Casadi/Core/Classes/SparsityInterfaceCommon.hs b/Casadi/Core/Classes/SparsityInterfaceCommon.hs
--- a/Casadi/Core/Classes/SparsityInterfaceCommon.hs
+++ b/Casadi/Core/Classes/SparsityInterfaceCommon.hs
@@ -25,7 +25,7 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
diff --git a/Casadi/Core/Classes/StabilizedQpSolver.hs b/Casadi/Core/Classes/StabilizedQpSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/StabilizedQpSolver.hs
+++ /dev/null
@@ -1,183 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.StabilizedQpSolver
-       (
-         StabilizedQpSolver,
-         StabilizedQpSolverClass(..),
-         stabilizedQpSolver__0,
-         stabilizedQpSolver__1,
-         stabilizedQpSolver__2,
-         stabilizedQpSolver_doc,
-         stabilizedQpSolver_generateNativeCode,
-         stabilizedQpSolver_hasPlugin,
-         stabilizedQpSolver_loadPlugin,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR__0" c_casadi__StabilizedQpSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr StabilizedQpSolver')
-casadi__StabilizedQpSolver__CONSTRUCTOR__0
-  :: String -> String -> M.Map String Sparsity -> IO StabilizedQpSolver
-casadi__StabilizedQpSolver__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__StabilizedQpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-stabilizedQpSolver__0 :: String -> String -> M.Map String Sparsity -> IO StabilizedQpSolver
-stabilizedQpSolver__0 = casadi__StabilizedQpSolver__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR__1" c_casadi__StabilizedQpSolver__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr StabilizedQpSolver')
-casadi__StabilizedQpSolver__CONSTRUCTOR__1
-  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO StabilizedQpSolver
-casadi__StabilizedQpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__StabilizedQpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-stabilizedQpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO StabilizedQpSolver
-stabilizedQpSolver__1 = casadi__StabilizedQpSolver__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR__2" c_casadi__StabilizedQpSolver__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr StabilizedQpSolver')
-casadi__StabilizedQpSolver__CONSTRUCTOR__2
-  :: IO StabilizedQpSolver
-casadi__StabilizedQpSolver__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__StabilizedQpSolver__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-stabilizedQpSolver__2 :: IO StabilizedQpSolver
-stabilizedQpSolver__2 = casadi__StabilizedQpSolver__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__StabilizedQpSolver__doc" c_casadi__StabilizedQpSolver__doc
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
-casadi__StabilizedQpSolver__doc
-  :: String -> IO String
-casadi__StabilizedQpSolver__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__StabilizedQpSolver__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-stabilizedQpSolver_doc :: String -> IO String
-stabilizedQpSolver_doc = casadi__StabilizedQpSolver__doc
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__StabilizedQpSolver__generateNativeCode" c_casadi__StabilizedQpSolver__generateNativeCode
-  :: Ptr (Ptr StdString) -> Ptr StabilizedQpSolver' -> Ptr StdString -> IO ()
-casadi__StabilizedQpSolver__generateNativeCode
-  :: StabilizedQpSolver -> String -> IO ()
-casadi__StabilizedQpSolver__generateNativeCode x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__StabilizedQpSolver__generateNativeCode errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-stabilizedQpSolver_generateNativeCode :: StabilizedQpSolverClass a => a -> String -> IO ()
-stabilizedQpSolver_generateNativeCode x = casadi__StabilizedQpSolver__generateNativeCode (castStabilizedQpSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__StabilizedQpSolver__hasPlugin" c_casadi__StabilizedQpSolver__hasPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
-casadi__StabilizedQpSolver__hasPlugin
-  :: String -> IO Bool
-casadi__StabilizedQpSolver__hasPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__StabilizedQpSolver__hasPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-stabilizedQpSolver_hasPlugin :: String -> IO Bool
-stabilizedQpSolver_hasPlugin = casadi__StabilizedQpSolver__hasPlugin
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__StabilizedQpSolver__loadPlugin" c_casadi__StabilizedQpSolver__loadPlugin
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
-casadi__StabilizedQpSolver__loadPlugin
-  :: String -> IO ()
-casadi__StabilizedQpSolver__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__StabilizedQpSolver__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-stabilizedQpSolver_loadPlugin :: String -> IO ()
-stabilizedQpSolver_loadPlugin = casadi__StabilizedQpSolver__loadPlugin
-
diff --git a/Casadi/Core/Classes/Switch.hs b/Casadi/Core/Classes/Switch.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/Switch.hs
+++ /dev/null
@@ -1,145 +0,0 @@
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# Language ForeignFunctionInterface #-}
-{-# Language FlexibleInstances #-}
-{-# Language MultiParamTypeClasses #-}
-
-module Casadi.Core.Classes.Switch
-       (
-         Switch,
-         SwitchClass(..),
-         switch__0,
-         switch__1,
-         switch__2,
-         switch__3,
-         switch__4,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-import Foreign.ForeignPtr ( newForeignPtr )
-import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
--- direct wrapper
-foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__0" c_casadi__Switch__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> IO (Ptr Switch')
-casadi__Switch__CONSTRUCTOR__0
-  :: String -> Function -> Function -> IO Switch
-casadi__Switch__CONSTRUCTOR__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Switch__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-switch__0 :: String -> Function -> Function -> IO Switch
-switch__0 = casadi__Switch__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__1" c_casadi__Switch__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Switch')
-casadi__Switch__CONSTRUCTOR__1
-  :: String -> Function -> Function -> M.Map String GenericType -> IO Switch
-casadi__Switch__CONSTRUCTOR__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Switch__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-switch__1 :: String -> Function -> Function -> M.Map String GenericType -> IO Switch
-switch__1 = casadi__Switch__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__2" c_casadi__Switch__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Function')) -> Ptr Function' -> IO (Ptr Switch')
-casadi__Switch__CONSTRUCTOR__2
-  :: String -> Vector Function -> Function -> IO Switch
-casadi__Switch__CONSTRUCTOR__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Switch__CONSTRUCTOR__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-switch__2 :: String -> Vector Function -> Function -> IO Switch
-switch__2 = casadi__Switch__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__3" c_casadi__Switch__CONSTRUCTOR__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Function')) -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Switch')
-casadi__Switch__CONSTRUCTOR__3
-  :: String -> Vector Function -> Function -> M.Map String GenericType -> IO Switch
-casadi__Switch__CONSTRUCTOR__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Switch__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-switch__3 :: String -> Vector Function -> Function -> M.Map String GenericType -> IO Switch
-switch__3 = casadi__Switch__CONSTRUCTOR__3
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__4" c_casadi__Switch__CONSTRUCTOR__4
-  :: Ptr (Ptr StdString) -> IO (Ptr Switch')
-casadi__Switch__CONSTRUCTOR__4
-  :: IO Switch
-casadi__Switch__CONSTRUCTOR__4  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Switch__CONSTRUCTOR__4 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-switch__4 :: IO Switch
-switch__4 = casadi__Switch__CONSTRUCTOR__4
-
diff --git a/Casadi/Core/Classes/Variable.hs b/Casadi/Core/Classes/Variable.hs
--- a/Casadi/Core/Classes/Variable.hs
+++ b/Casadi/Core/Classes/Variable.hs
@@ -31,25 +31,32 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__Variable__CONSTRUCTOR__0" c_casadi__Variable__CONSTRUCTOR__0
   :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr Variable')
+
 casadi__Variable__CONSTRUCTOR__0
   :: String -> IO Variable
-casadi__Variable__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Variable__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Variable__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Variable__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 variable__0 :: String -> IO Variable
 variable__0 = casadi__Variable__CONSTRUCTOR__0
@@ -58,19 +65,27 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Variable__CONSTRUCTOR__1" c_casadi__Variable__CONSTRUCTOR__1
   :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr Variable')
+
 casadi__Variable__CONSTRUCTOR__1
   :: String -> Sparsity -> IO Variable
-casadi__Variable__CONSTRUCTOR__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Variable__CONSTRUCTOR__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Variable__CONSTRUCTOR__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Variable__CONSTRUCTOR__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
 -- classy wrapper
 variable__1 :: String -> Sparsity -> IO Variable
 variable__1 = casadi__Variable__CONSTRUCTOR__1
@@ -79,18 +94,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Variable__CONSTRUCTOR__2" c_casadi__Variable__CONSTRUCTOR__2
   :: Ptr (Ptr StdString) -> IO (Ptr Variable')
+
 casadi__Variable__CONSTRUCTOR__2
   :: IO Variable
-casadi__Variable__CONSTRUCTOR__2  =
+casadi__Variable__CONSTRUCTOR__2  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Variable__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Variable__CONSTRUCTOR__2 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 variable__2 :: IO Variable
 variable__2 = casadi__Variable__CONSTRUCTOR__2
@@ -99,18 +121,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Variable__name" c_casadi__Variable__name
   :: Ptr (Ptr StdString) -> Ptr Variable' -> IO (Ptr StdString)
+
 casadi__Variable__name
   :: Variable -> IO String
-casadi__Variable__name x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Variable__name errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Variable__name x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Variable__name errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 variable_name :: VariableClass a => a -> IO String
 variable_name x = casadi__Variable__name (castVariable x)
@@ -119,18 +148,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Variable__getRepresentation" c_casadi__Variable__getRepresentation
   :: Ptr (Ptr StdString) -> Ptr Variable' -> IO (Ptr StdString)
+
 casadi__Variable__getRepresentation
   :: Variable -> IO String
-casadi__Variable__getRepresentation x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Variable__getRepresentation errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Variable__getRepresentation x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Variable__getRepresentation errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 variable_getRepresentation :: VariableClass a => a -> IO String
 variable_getRepresentation x = casadi__Variable__getRepresentation (castVariable x)
@@ -139,16 +175,23 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__Variable__getDescription" c_casadi__Variable__getDescription
   :: Ptr (Ptr StdString) -> Ptr Variable' -> IO (Ptr StdString)
+
 casadi__Variable__getDescription
   :: Variable -> IO String
-casadi__Variable__getDescription x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__Variable__getDescription errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__Variable__getDescription x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__Variable__getDescription errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Classes/XmlFile.hs b/Casadi/Core/Classes/XmlFile.hs
--- a/Casadi/Core/Classes/XmlFile.hs
+++ b/Casadi/Core/Classes/XmlFile.hs
@@ -29,25 +29,32 @@
 
 import Casadi.Internal.FormatException ( formatException )
 import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 import Casadi.Core.Data
 import Casadi.Core.Enums
 -- direct wrapper
 foreign import ccall unsafe "casadi__XmlFile__CONSTRUCTOR__0" c_casadi__XmlFile__CONSTRUCTOR__0
   :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr XmlFile')
+
 casadi__XmlFile__CONSTRUCTOR__0
   :: String -> IO XmlFile
-casadi__XmlFile__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__XmlFile__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__XmlFile__CONSTRUCTOR__0 x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__XmlFile__CONSTRUCTOR__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 xmlFile__0 :: String -> IO XmlFile
 xmlFile__0 = casadi__XmlFile__CONSTRUCTOR__0
@@ -56,18 +63,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__XmlFile__CONSTRUCTOR__1" c_casadi__XmlFile__CONSTRUCTOR__1
   :: Ptr (Ptr StdString) -> IO (Ptr XmlFile')
+
 casadi__XmlFile__CONSTRUCTOR__1
   :: IO XmlFile
-casadi__XmlFile__CONSTRUCTOR__1  =
+casadi__XmlFile__CONSTRUCTOR__1  = do
 
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__XmlFile__CONSTRUCTOR__1 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__XmlFile__CONSTRUCTOR__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
 -- classy wrapper
 xmlFile__1 :: IO XmlFile
 xmlFile__1 = casadi__XmlFile__CONSTRUCTOR__1
@@ -76,18 +90,25 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__XmlFile__doc" c_casadi__XmlFile__doc
   :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
 casadi__XmlFile__doc
   :: String -> IO String
-casadi__XmlFile__doc x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__XmlFile__doc errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__XmlFile__doc x0 = do
+  x0' <- marshal x0
 
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__XmlFile__doc errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
 
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
 -- classy wrapper
 xmlFile_doc :: String -> IO String
 xmlFile_doc = casadi__XmlFile__doc
@@ -96,16 +117,23 @@
 -- direct wrapper
 foreign import ccall unsafe "casadi__XmlFile__loadPlugin" c_casadi__XmlFile__loadPlugin
   :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
 casadi__XmlFile__loadPlugin
   :: String -> IO ()
-casadi__XmlFile__loadPlugin x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__XmlFile__loadPlugin errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+casadi__XmlFile__loadPlugin x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi__XmlFile__loadPlugin errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
 
 
 -- classy wrapper
diff --git a/Casadi/Core/Data.hs b/Casadi/Core/Data.hs
--- a/Casadi/Core/Data.hs
+++ b/Casadi/Core/Data.hs
@@ -25,1844 +25,641 @@
   castCallback = id
 
 -- baseclass instances
-instance FunctorClass Callback where
-  castFunctor (Callback x) = Functor (castForeignPtr x)
-
-instance SharedObjectClass Callback where
-  castSharedObject (Callback x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Callback (Ptr Callback') where
-  marshal (Callback x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Callback x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Callback" 
-  c_delete_casadi__Callback :: FunPtr (Ptr Callback' -> IO ())
-instance WrapReturn (Ptr Callback') Callback where
-  wrapReturn = (fmap Callback) . (newForeignPtr c_delete_casadi__Callback)
-
-
--- raw decl
-data Callback2'
--- data decl
-{-|
--}
-newtype Callback2 = Callback2 (ForeignPtr Callback2')
--- typeclass decl
-class Callback2Class a where
-  castCallback2 :: a -> Callback2
-instance Callback2Class Callback2 where
-  castCallback2 = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal Callback2 (Ptr Callback2') where
-  marshal (Callback2 x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Callback2 x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Callback2" 
-  c_delete_casadi__Callback2 :: FunPtr (Ptr Callback2' -> IO ())
-instance WrapReturn (Ptr Callback2') Callback2 where
-  wrapReturn = (fmap Callback2) . (newForeignPtr c_delete_casadi__Callback2)
-
-
--- raw decl
-data CasadiMeta'
--- data decl
-{-|
--}
-newtype CasadiMeta = CasadiMeta (ForeignPtr CasadiMeta')
--- typeclass decl
-class CasadiMetaClass a where
-  castCasadiMeta :: a -> CasadiMeta
-instance CasadiMetaClass CasadiMeta where
-  castCasadiMeta = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal CasadiMeta (Ptr CasadiMeta') where
-  marshal (CasadiMeta x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (CasadiMeta x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CasadiMeta" 
-  c_delete_casadi__CasadiMeta :: FunPtr (Ptr CasadiMeta' -> IO ())
-instance WrapReturn (Ptr CasadiMeta') CasadiMeta where
-  wrapReturn = (fmap CasadiMeta) . (newForeignPtr c_delete_casadi__CasadiMeta)
-
-
--- raw decl
-data CasadiOptions'
--- data decl
-{-|
--}
-newtype CasadiOptions = CasadiOptions (ForeignPtr CasadiOptions')
--- typeclass decl
-class CasadiOptionsClass a where
-  castCasadiOptions :: a -> CasadiOptions
-instance CasadiOptionsClass CasadiOptions where
-  castCasadiOptions = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal CasadiOptions (Ptr CasadiOptions') where
-  marshal (CasadiOptions x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (CasadiOptions x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CasadiOptions" 
-  c_delete_casadi__CasadiOptions :: FunPtr (Ptr CasadiOptions' -> IO ())
-instance WrapReturn (Ptr CasadiOptions') CasadiOptions where
-  wrapReturn = (fmap CasadiOptions) . (newForeignPtr c_delete_casadi__CasadiOptions)
-
-
--- raw decl
-data CleSolver'
--- data decl
-{-|
--}
-newtype CleSolver = CleSolver (ForeignPtr CleSolver')
--- typeclass decl
-class CleSolverClass a where
-  castCleSolver :: a -> CleSolver
-instance CleSolverClass CleSolver where
-  castCleSolver = id
-
--- baseclass instances
-instance FunctionClass CleSolver where
-  castFunction (CleSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass CleSolver where
-  castOptionsFunctionality (CleSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass CleSolver where
-  castSharedObject (CleSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass CleSolver where
-  castIOInterfaceFunction (CleSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal CleSolver (Ptr CleSolver') where
-  marshal (CleSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (CleSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CleSolver" 
-  c_delete_casadi__CleSolver :: FunPtr (Ptr CleSolver' -> IO ())
-instance WrapReturn (Ptr CleSolver') CleSolver where
-  wrapReturn = (fmap CleSolver) . (newForeignPtr c_delete_casadi__CleSolver)
-
-
--- raw decl
-data CodeGenerator'
--- data decl
-{-|
--}
-newtype CodeGenerator = CodeGenerator (ForeignPtr CodeGenerator')
--- typeclass decl
-class CodeGeneratorClass a where
-  castCodeGenerator :: a -> CodeGenerator
-instance CodeGeneratorClass CodeGenerator where
-  castCodeGenerator = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal CodeGenerator (Ptr CodeGenerator') where
-  marshal (CodeGenerator x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (CodeGenerator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CodeGenerator" 
-  c_delete_casadi__CodeGenerator :: FunPtr (Ptr CodeGenerator' -> IO ())
-instance WrapReturn (Ptr CodeGenerator') CodeGenerator where
-  wrapReturn = (fmap CodeGenerator) . (newForeignPtr c_delete_casadi__CodeGenerator)
-
-
--- raw decl
-data Compiler'
--- data decl
-{-|
--}
-newtype Compiler = Compiler (ForeignPtr Compiler')
--- typeclass decl
-class CompilerClass a where
-  castCompiler :: a -> Compiler
-instance CompilerClass Compiler where
-  castCompiler = id
-
--- baseclass instances
-instance OptionsFunctionalityClass Compiler where
-  castOptionsFunctionality (Compiler x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass Compiler where
-  castSharedObject (Compiler x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Compiler (Ptr Compiler') where
-  marshal (Compiler x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Compiler x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Compiler" 
-  c_delete_casadi__Compiler :: FunPtr (Ptr Compiler' -> IO ())
-instance WrapReturn (Ptr Compiler') Compiler where
-  wrapReturn = (fmap Compiler) . (newForeignPtr c_delete_casadi__Compiler)
-
-
--- raw decl
-data ControlSimulator'
--- data decl
-{-|
--}
-newtype ControlSimulator = ControlSimulator (ForeignPtr ControlSimulator')
--- typeclass decl
-class ControlSimulatorClass a where
-  castControlSimulator :: a -> ControlSimulator
-instance ControlSimulatorClass ControlSimulator where
-  castControlSimulator = id
-
--- baseclass instances
-instance FunctionClass ControlSimulator where
-  castFunction (ControlSimulator x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass ControlSimulator where
-  castOptionsFunctionality (ControlSimulator x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass ControlSimulator where
-  castSharedObject (ControlSimulator x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass ControlSimulator where
-  castIOInterfaceFunction (ControlSimulator x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal ControlSimulator (Ptr ControlSimulator') where
-  marshal (ControlSimulator x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (ControlSimulator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__ControlSimulator" 
-  c_delete_casadi__ControlSimulator :: FunPtr (Ptr ControlSimulator' -> IO ())
-instance WrapReturn (Ptr ControlSimulator') ControlSimulator where
-  wrapReturn = (fmap ControlSimulator) . (newForeignPtr c_delete_casadi__ControlSimulator)
-
-
--- raw decl
-data CustomEvaluate'
--- data decl
-{-|
--}
-newtype CustomEvaluate = CustomEvaluate (ForeignPtr CustomEvaluate')
--- typeclass decl
-class CustomEvaluateClass a where
-  castCustomEvaluate :: a -> CustomEvaluate
-instance CustomEvaluateClass CustomEvaluate where
-  castCustomEvaluate = id
-
--- baseclass instances
-instance FunctorClass CustomEvaluate where
-  castFunctor (CustomEvaluate x) = Functor (castForeignPtr x)
-
-instance SharedObjectClass CustomEvaluate where
-  castSharedObject (CustomEvaluate x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal CustomEvaluate (Ptr CustomEvaluate') where
-  marshal (CustomEvaluate x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (CustomEvaluate x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CustomEvaluate" 
-  c_delete_casadi__CustomEvaluate :: FunPtr (Ptr CustomEvaluate' -> IO ())
-instance WrapReturn (Ptr CustomEvaluate') CustomEvaluate where
-  wrapReturn = (fmap CustomEvaluate) . (newForeignPtr c_delete_casadi__CustomEvaluate)
-
-
--- raw decl
-data CustomFunction'
--- data decl
-{-|
--}
-newtype CustomFunction = CustomFunction (ForeignPtr CustomFunction')
--- typeclass decl
-class CustomFunctionClass a where
-  castCustomFunction :: a -> CustomFunction
-instance CustomFunctionClass CustomFunction where
-  castCustomFunction = id
-
--- baseclass instances
-instance FunctionClass CustomFunction where
-  castFunction (CustomFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass CustomFunction where
-  castOptionsFunctionality (CustomFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass CustomFunction where
-  castSharedObject (CustomFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass CustomFunction where
-  castIOInterfaceFunction (CustomFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal CustomFunction (Ptr CustomFunction') where
-  marshal (CustomFunction x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (CustomFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CustomFunction" 
-  c_delete_casadi__CustomFunction :: FunPtr (Ptr CustomFunction' -> IO ())
-instance WrapReturn (Ptr CustomFunction') CustomFunction where
-  wrapReturn = (fmap CustomFunction) . (newForeignPtr c_delete_casadi__CustomFunction)
-
-
--- raw decl
-data DMatrix'
--- data decl
-{-|
--}
-newtype DMatrix = DMatrix (ForeignPtr DMatrix')
--- typeclass decl
-class DMatrixClass a where
-  castDMatrix :: a -> DMatrix
-instance DMatrixClass DMatrix where
-  castDMatrix = id
-
--- baseclass instances
-instance GenericExpressionCommonClass DMatrix where
-  castGenericExpressionCommon (DMatrix x) = GenericExpressionCommon (castForeignPtr x)
-
-instance GenericMatrixCommonClass DMatrix where
-  castGenericMatrixCommon (DMatrix x) = GenericMatrixCommon (castForeignPtr x)
-
-instance MatrixCommonClass DMatrix where
-  castMatrixCommon (DMatrix x) = MatrixCommon (castForeignPtr x)
-
-instance SparsityInterfaceCommonClass DMatrix where
-  castSparsityInterfaceCommon (DMatrix x) = SparsityInterfaceCommon (castForeignPtr x)
-
-
--- helper instances
-instance Marshal DMatrix (Ptr DMatrix') where
-  marshal (DMatrix x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (DMatrix x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DMatrix" 
-  c_delete_casadi__DMatrix :: FunPtr (Ptr DMatrix' -> IO ())
-instance WrapReturn (Ptr DMatrix') DMatrix where
-  wrapReturn = (fmap DMatrix) . (newForeignPtr c_delete_casadi__DMatrix)
-
-
--- raw decl
-data DaeBuilder'
--- data decl
-{-|
--}
-newtype DaeBuilder = DaeBuilder (ForeignPtr DaeBuilder')
--- typeclass decl
-class DaeBuilderClass a where
-  castDaeBuilder :: a -> DaeBuilder
-instance DaeBuilderClass DaeBuilder where
-  castDaeBuilder = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal DaeBuilder (Ptr DaeBuilder') where
-  marshal (DaeBuilder x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (DaeBuilder x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DaeBuilder" 
-  c_delete_casadi__DaeBuilder :: FunPtr (Ptr DaeBuilder' -> IO ())
-instance WrapReturn (Ptr DaeBuilder') DaeBuilder where
-  wrapReturn = (fmap DaeBuilder) . (newForeignPtr c_delete_casadi__DaeBuilder)
-
-
--- raw decl
-data DerivativeGenerator'
--- data decl
-{-|
--}
-newtype DerivativeGenerator = DerivativeGenerator (ForeignPtr DerivativeGenerator')
--- typeclass decl
-class DerivativeGeneratorClass a where
-  castDerivativeGenerator :: a -> DerivativeGenerator
-instance DerivativeGeneratorClass DerivativeGenerator where
-  castDerivativeGenerator = id
-
--- baseclass instances
-instance FunctorClass DerivativeGenerator where
-  castFunctor (DerivativeGenerator x) = Functor (castForeignPtr x)
-
-instance SharedObjectClass DerivativeGenerator where
-  castSharedObject (DerivativeGenerator x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal DerivativeGenerator (Ptr DerivativeGenerator') where
-  marshal (DerivativeGenerator x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (DerivativeGenerator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DerivativeGenerator" 
-  c_delete_casadi__DerivativeGenerator :: FunPtr (Ptr DerivativeGenerator' -> IO ())
-instance WrapReturn (Ptr DerivativeGenerator') DerivativeGenerator where
-  wrapReturn = (fmap DerivativeGenerator) . (newForeignPtr c_delete_casadi__DerivativeGenerator)
-
-
--- raw decl
-data DerivativeGenerator2'
--- data decl
-{-|
--}
-newtype DerivativeGenerator2 = DerivativeGenerator2 (ForeignPtr DerivativeGenerator2')
--- typeclass decl
-class DerivativeGenerator2Class a where
-  castDerivativeGenerator2 :: a -> DerivativeGenerator2
-instance DerivativeGenerator2Class DerivativeGenerator2 where
-  castDerivativeGenerator2 = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal DerivativeGenerator2 (Ptr DerivativeGenerator2') where
-  marshal (DerivativeGenerator2 x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (DerivativeGenerator2 x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DerivativeGenerator2" 
-  c_delete_casadi__DerivativeGenerator2 :: FunPtr (Ptr DerivativeGenerator2' -> IO ())
-instance WrapReturn (Ptr DerivativeGenerator2') DerivativeGenerator2 where
-  wrapReturn = (fmap DerivativeGenerator2) . (newForeignPtr c_delete_casadi__DerivativeGenerator2)
-
-
--- raw decl
-data DleSolver'
--- data decl
-{-|
--}
-newtype DleSolver = DleSolver (ForeignPtr DleSolver')
--- typeclass decl
-class DleSolverClass a where
-  castDleSolver :: a -> DleSolver
-instance DleSolverClass DleSolver where
-  castDleSolver = id
-
--- baseclass instances
-instance FunctionClass DleSolver where
-  castFunction (DleSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass DleSolver where
-  castOptionsFunctionality (DleSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass DleSolver where
-  castSharedObject (DleSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass DleSolver where
-  castIOInterfaceFunction (DleSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal DleSolver (Ptr DleSolver') where
-  marshal (DleSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (DleSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DleSolver" 
-  c_delete_casadi__DleSolver :: FunPtr (Ptr DleSolver' -> IO ())
-instance WrapReturn (Ptr DleSolver') DleSolver where
-  wrapReturn = (fmap DleSolver) . (newForeignPtr c_delete_casadi__DleSolver)
-
-
--- raw decl
-data DpleSolver'
--- data decl
-{-|
--}
-newtype DpleSolver = DpleSolver (ForeignPtr DpleSolver')
--- typeclass decl
-class DpleSolverClass a where
-  castDpleSolver :: a -> DpleSolver
-instance DpleSolverClass DpleSolver where
-  castDpleSolver = id
-
--- baseclass instances
-instance FunctionClass DpleSolver where
-  castFunction (DpleSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass DpleSolver where
-  castOptionsFunctionality (DpleSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass DpleSolver where
-  castSharedObject (DpleSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass DpleSolver where
-  castIOInterfaceFunction (DpleSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal DpleSolver (Ptr DpleSolver') where
-  marshal (DpleSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (DpleSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DpleSolver" 
-  c_delete_casadi__DpleSolver :: FunPtr (Ptr DpleSolver' -> IO ())
-instance WrapReturn (Ptr DpleSolver') DpleSolver where
-  wrapReturn = (fmap DpleSolver) . (newForeignPtr c_delete_casadi__DpleSolver)
-
-
--- raw decl
-data ExternalFunction'
--- data decl
-{-|
--}
-newtype ExternalFunction = ExternalFunction (ForeignPtr ExternalFunction')
--- typeclass decl
-class ExternalFunctionClass a where
-  castExternalFunction :: a -> ExternalFunction
-instance ExternalFunctionClass ExternalFunction where
-  castExternalFunction = id
-
--- baseclass instances
-instance FunctionClass ExternalFunction where
-  castFunction (ExternalFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass ExternalFunction where
-  castOptionsFunctionality (ExternalFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass ExternalFunction where
-  castSharedObject (ExternalFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass ExternalFunction where
-  castIOInterfaceFunction (ExternalFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal ExternalFunction (Ptr ExternalFunction') where
-  marshal (ExternalFunction x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (ExternalFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__ExternalFunction" 
-  c_delete_casadi__ExternalFunction :: FunPtr (Ptr ExternalFunction' -> IO ())
-instance WrapReturn (Ptr ExternalFunction') ExternalFunction where
-  wrapReturn = (fmap ExternalFunction) . (newForeignPtr c_delete_casadi__ExternalFunction)
-
-
--- raw decl
-data Function'
--- data decl
-{-|
--}
-newtype Function = Function (ForeignPtr Function')
--- typeclass decl
-class FunctionClass a where
-  castFunction :: a -> Function
-instance FunctionClass Function where
-  castFunction = id
-
--- baseclass instances
-instance OptionsFunctionalityClass Function where
-  castOptionsFunctionality (Function x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass Function where
-  castSharedObject (Function x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Function where
-  castIOInterfaceFunction (Function x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Function (Ptr Function') where
-  marshal (Function x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Function x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Function" 
-  c_delete_casadi__Function :: FunPtr (Ptr Function' -> IO ())
-instance WrapReturn (Ptr Function') Function where
-  wrapReturn = (fmap Function) . (newForeignPtr c_delete_casadi__Function)
-
-
--- raw decl
-data Functor'
--- data decl
-{-|
--}
-newtype Functor = Functor (ForeignPtr Functor')
--- typeclass decl
-class FunctorClass a where
-  castFunctor :: a -> Functor
-instance FunctorClass Functor where
-  castFunctor = id
-
--- baseclass instances
-instance SharedObjectClass Functor where
-  castSharedObject (Functor x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Functor (Ptr Functor') where
-  marshal (Functor x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Functor x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Functor" 
-  c_delete_casadi__Functor :: FunPtr (Ptr Functor' -> IO ())
-instance WrapReturn (Ptr Functor') Functor where
-  wrapReturn = (fmap Functor) . (newForeignPtr c_delete_casadi__Functor)
-
-
--- raw decl
-data GenericExpressionCommon'
--- data decl
-{-|
--}
-newtype GenericExpressionCommon = GenericExpressionCommon (ForeignPtr GenericExpressionCommon')
--- typeclass decl
-class GenericExpressionCommonClass a where
-  castGenericExpressionCommon :: a -> GenericExpressionCommon
-instance GenericExpressionCommonClass GenericExpressionCommon where
-  castGenericExpressionCommon = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal GenericExpressionCommon (Ptr GenericExpressionCommon') where
-  marshal (GenericExpressionCommon x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (GenericExpressionCommon x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__GenericExpressionCommon" 
-  c_delete_casadi__GenericExpressionCommon :: FunPtr (Ptr GenericExpressionCommon' -> IO ())
-instance WrapReturn (Ptr GenericExpressionCommon') GenericExpressionCommon where
-  wrapReturn = (fmap GenericExpressionCommon) . (newForeignPtr c_delete_casadi__GenericExpressionCommon)
-
-
--- raw decl
-data GenericMatrixCommon'
--- data decl
-{-|
--}
-newtype GenericMatrixCommon = GenericMatrixCommon (ForeignPtr GenericMatrixCommon')
--- typeclass decl
-class GenericMatrixCommonClass a where
-  castGenericMatrixCommon :: a -> GenericMatrixCommon
-instance GenericMatrixCommonClass GenericMatrixCommon where
-  castGenericMatrixCommon = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal GenericMatrixCommon (Ptr GenericMatrixCommon') where
-  marshal (GenericMatrixCommon x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (GenericMatrixCommon x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__GenericMatrixCommon" 
-  c_delete_casadi__GenericMatrixCommon :: FunPtr (Ptr GenericMatrixCommon' -> IO ())
-instance WrapReturn (Ptr GenericMatrixCommon') GenericMatrixCommon where
-  wrapReturn = (fmap GenericMatrixCommon) . (newForeignPtr c_delete_casadi__GenericMatrixCommon)
-
-
--- raw decl
-data GenericType'
--- data decl
-{-|
--}
-newtype GenericType = GenericType (ForeignPtr GenericType')
--- typeclass decl
-class GenericTypeClass a where
-  castGenericType :: a -> GenericType
-instance GenericTypeClass GenericType where
-  castGenericType = id
-
--- baseclass instances
-instance SharedObjectClass GenericType where
-  castSharedObject (GenericType x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal GenericType (Ptr GenericType') where
-  marshal (GenericType x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (GenericType x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__GenericType" 
-  c_delete_casadi__GenericType :: FunPtr (Ptr GenericType' -> IO ())
-instance WrapReturn (Ptr GenericType') GenericType where
-  wrapReturn = (fmap GenericType) . (newForeignPtr c_delete_casadi__GenericType)
-
-
--- raw decl
-data HomotopyNlpSolver'
--- data decl
-{-|
--}
-newtype HomotopyNlpSolver = HomotopyNlpSolver (ForeignPtr HomotopyNlpSolver')
--- typeclass decl
-class HomotopyNlpSolverClass a where
-  castHomotopyNlpSolver :: a -> HomotopyNlpSolver
-instance HomotopyNlpSolverClass HomotopyNlpSolver where
-  castHomotopyNlpSolver = id
-
--- baseclass instances
-instance FunctionClass HomotopyNlpSolver where
-  castFunction (HomotopyNlpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass HomotopyNlpSolver where
-  castOptionsFunctionality (HomotopyNlpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass HomotopyNlpSolver where
-  castSharedObject (HomotopyNlpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass HomotopyNlpSolver where
-  castIOInterfaceFunction (HomotopyNlpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal HomotopyNlpSolver (Ptr HomotopyNlpSolver') where
-  marshal (HomotopyNlpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (HomotopyNlpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__HomotopyNlpSolver" 
-  c_delete_casadi__HomotopyNlpSolver :: FunPtr (Ptr HomotopyNlpSolver' -> IO ())
-instance WrapReturn (Ptr HomotopyNlpSolver') HomotopyNlpSolver where
-  wrapReturn = (fmap HomotopyNlpSolver) . (newForeignPtr c_delete_casadi__HomotopyNlpSolver)
-
-
--- raw decl
-data IMatrix'
--- data decl
-{-|
--}
-newtype IMatrix = IMatrix (ForeignPtr IMatrix')
--- typeclass decl
-class IMatrixClass a where
-  castIMatrix :: a -> IMatrix
-instance IMatrixClass IMatrix where
-  castIMatrix = id
-
--- baseclass instances
-instance GenericExpressionCommonClass IMatrix where
-  castGenericExpressionCommon (IMatrix x) = GenericExpressionCommon (castForeignPtr x)
-
-instance GenericMatrixCommonClass IMatrix where
-  castGenericMatrixCommon (IMatrix x) = GenericMatrixCommon (castForeignPtr x)
-
-instance MatrixCommonClass IMatrix where
-  castMatrixCommon (IMatrix x) = MatrixCommon (castForeignPtr x)
-
-instance SparsityInterfaceCommonClass IMatrix where
-  castSparsityInterfaceCommon (IMatrix x) = SparsityInterfaceCommon (castForeignPtr x)
-
-
--- helper instances
-instance Marshal IMatrix (Ptr IMatrix') where
-  marshal (IMatrix x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (IMatrix x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__IMatrix" 
-  c_delete_casadi__IMatrix :: FunPtr (Ptr IMatrix' -> IO ())
-instance WrapReturn (Ptr IMatrix') IMatrix where
-  wrapReturn = (fmap IMatrix) . (newForeignPtr c_delete_casadi__IMatrix)
-
-
--- raw decl
-data ImplicitFunction'
--- data decl
-{-|
--}
-newtype ImplicitFunction = ImplicitFunction (ForeignPtr ImplicitFunction')
--- typeclass decl
-class ImplicitFunctionClass a where
-  castImplicitFunction :: a -> ImplicitFunction
-instance ImplicitFunctionClass ImplicitFunction where
-  castImplicitFunction = id
-
--- baseclass instances
-instance FunctionClass ImplicitFunction where
-  castFunction (ImplicitFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass ImplicitFunction where
-  castOptionsFunctionality (ImplicitFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass ImplicitFunction where
-  castSharedObject (ImplicitFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass ImplicitFunction where
-  castIOInterfaceFunction (ImplicitFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal ImplicitFunction (Ptr ImplicitFunction') where
-  marshal (ImplicitFunction x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (ImplicitFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__ImplicitFunction" 
-  c_delete_casadi__ImplicitFunction :: FunPtr (Ptr ImplicitFunction' -> IO ())
-instance WrapReturn (Ptr ImplicitFunction') ImplicitFunction where
-  wrapReturn = (fmap ImplicitFunction) . (newForeignPtr c_delete_casadi__ImplicitFunction)
-
-
--- raw decl
-data Integrator'
--- data decl
-{-|
--}
-newtype Integrator = Integrator (ForeignPtr Integrator')
--- typeclass decl
-class IntegratorClass a where
-  castIntegrator :: a -> Integrator
-instance IntegratorClass Integrator where
-  castIntegrator = id
-
--- baseclass instances
-instance FunctionClass Integrator where
-  castFunction (Integrator x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Integrator where
-  castOptionsFunctionality (Integrator x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass Integrator where
-  castSharedObject (Integrator x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Integrator where
-  castIOInterfaceFunction (Integrator x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Integrator (Ptr Integrator') where
-  marshal (Integrator x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Integrator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Integrator" 
-  c_delete_casadi__Integrator :: FunPtr (Ptr Integrator' -> IO ())
-instance WrapReturn (Ptr Integrator') Integrator where
-  wrapReturn = (fmap Integrator) . (newForeignPtr c_delete_casadi__Integrator)
-
-
--- raw decl
-data IterationCallback'
--- data decl
-{-|
--}
-newtype IterationCallback = IterationCallback (ForeignPtr IterationCallback')
--- typeclass decl
-class IterationCallbackClass a where
-  castIterationCallback :: a -> IterationCallback
-instance IterationCallbackClass IterationCallback where
-  castIterationCallback = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal IterationCallback (Ptr IterationCallback') where
-  marshal (IterationCallback x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (IterationCallback x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__IterationCallback" 
-  c_delete_casadi__IterationCallback :: FunPtr (Ptr IterationCallback' -> IO ())
-instance WrapReturn (Ptr IterationCallback') IterationCallback where
-  wrapReturn = (fmap IterationCallback) . (newForeignPtr c_delete_casadi__IterationCallback)
-
-
--- raw decl
-data KernelSum2D'
--- data decl
-{-|
--}
-newtype KernelSum2D = KernelSum2D (ForeignPtr KernelSum2D')
--- typeclass decl
-class KernelSum2DClass a where
-  castKernelSum2D :: a -> KernelSum2D
-instance KernelSum2DClass KernelSum2D where
-  castKernelSum2D = id
-
--- baseclass instances
-instance FunctionClass KernelSum2D where
-  castFunction (KernelSum2D x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass KernelSum2D where
-  castOptionsFunctionality (KernelSum2D x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass KernelSum2D where
-  castSharedObject (KernelSum2D x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass KernelSum2D where
-  castIOInterfaceFunction (KernelSum2D x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal KernelSum2D (Ptr KernelSum2D') where
-  marshal (KernelSum2D x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (KernelSum2D x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__KernelSum2D" 
-  c_delete_casadi__KernelSum2D :: FunPtr (Ptr KernelSum2D' -> IO ())
-instance WrapReturn (Ptr KernelSum2D') KernelSum2D where
-  wrapReturn = (fmap KernelSum2D) . (newForeignPtr c_delete_casadi__KernelSum2D)
-
-
--- raw decl
-data LinearSolver'
--- data decl
-{-|
--}
-newtype LinearSolver = LinearSolver (ForeignPtr LinearSolver')
--- typeclass decl
-class LinearSolverClass a where
-  castLinearSolver :: a -> LinearSolver
-instance LinearSolverClass LinearSolver where
-  castLinearSolver = id
-
--- baseclass instances
-instance FunctionClass LinearSolver where
-  castFunction (LinearSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass LinearSolver where
-  castOptionsFunctionality (LinearSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass LinearSolver where
-  castSharedObject (LinearSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass LinearSolver where
-  castIOInterfaceFunction (LinearSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal LinearSolver (Ptr LinearSolver') where
-  marshal (LinearSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (LinearSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__LinearSolver" 
-  c_delete_casadi__LinearSolver :: FunPtr (Ptr LinearSolver' -> IO ())
-instance WrapReturn (Ptr LinearSolver') LinearSolver where
-  wrapReturn = (fmap LinearSolver) . (newForeignPtr c_delete_casadi__LinearSolver)
-
-
--- raw decl
-data LpSolver'
--- data decl
-{-|
--}
-newtype LpSolver = LpSolver (ForeignPtr LpSolver')
--- typeclass decl
-class LpSolverClass a where
-  castLpSolver :: a -> LpSolver
-instance LpSolverClass LpSolver where
-  castLpSolver = id
-
--- baseclass instances
-instance FunctionClass LpSolver where
-  castFunction (LpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass LpSolver where
-  castOptionsFunctionality (LpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass LpSolver where
-  castSharedObject (LpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass LpSolver where
-  castIOInterfaceFunction (LpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal LpSolver (Ptr LpSolver') where
-  marshal (LpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (LpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__LpSolver" 
-  c_delete_casadi__LpSolver :: FunPtr (Ptr LpSolver' -> IO ())
-instance WrapReturn (Ptr LpSolver') LpSolver where
-  wrapReturn = (fmap LpSolver) . (newForeignPtr c_delete_casadi__LpSolver)
-
-
--- raw decl
-data LrDleSolver'
--- data decl
-{-|
--}
-newtype LrDleSolver = LrDleSolver (ForeignPtr LrDleSolver')
--- typeclass decl
-class LrDleSolverClass a where
-  castLrDleSolver :: a -> LrDleSolver
-instance LrDleSolverClass LrDleSolver where
-  castLrDleSolver = id
-
--- baseclass instances
-instance FunctionClass LrDleSolver where
-  castFunction (LrDleSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass LrDleSolver where
-  castOptionsFunctionality (LrDleSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass LrDleSolver where
-  castSharedObject (LrDleSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass LrDleSolver where
-  castIOInterfaceFunction (LrDleSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal LrDleSolver (Ptr LrDleSolver') where
-  marshal (LrDleSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (LrDleSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__LrDleSolver" 
-  c_delete_casadi__LrDleSolver :: FunPtr (Ptr LrDleSolver' -> IO ())
-instance WrapReturn (Ptr LrDleSolver') LrDleSolver where
-  wrapReturn = (fmap LrDleSolver) . (newForeignPtr c_delete_casadi__LrDleSolver)
-
-
--- raw decl
-data LrDpleSolver'
--- data decl
-{-|
--}
-newtype LrDpleSolver = LrDpleSolver (ForeignPtr LrDpleSolver')
--- typeclass decl
-class LrDpleSolverClass a where
-  castLrDpleSolver :: a -> LrDpleSolver
-instance LrDpleSolverClass LrDpleSolver where
-  castLrDpleSolver = id
-
--- baseclass instances
-instance FunctionClass LrDpleSolver where
-  castFunction (LrDpleSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass LrDpleSolver where
-  castOptionsFunctionality (LrDpleSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass LrDpleSolver where
-  castSharedObject (LrDpleSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass LrDpleSolver where
-  castIOInterfaceFunction (LrDpleSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal LrDpleSolver (Ptr LrDpleSolver') where
-  marshal (LrDpleSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (LrDpleSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__LrDpleSolver" 
-  c_delete_casadi__LrDpleSolver :: FunPtr (Ptr LrDpleSolver' -> IO ())
-instance WrapReturn (Ptr LrDpleSolver') LrDpleSolver where
-  wrapReturn = (fmap LrDpleSolver) . (newForeignPtr c_delete_casadi__LrDpleSolver)
-
-
--- raw decl
-data MX'
--- data decl
-{-|
--}
-newtype MX = MX (ForeignPtr MX')
--- typeclass decl
-class MXClass a where
-  castMX :: a -> MX
-instance MXClass MX where
-  castMX = id
-
--- baseclass instances
-instance GenericExpressionCommonClass MX where
-  castGenericExpressionCommon (MX x) = GenericExpressionCommon (castForeignPtr x)
-
-instance GenericMatrixCommonClass MX where
-  castGenericMatrixCommon (MX x) = GenericMatrixCommon (castForeignPtr x)
-
-instance SharedObjectClass MX where
-  castSharedObject (MX x) = SharedObject (castForeignPtr x)
-
-instance SparsityInterfaceCommonClass MX where
-  castSparsityInterfaceCommon (MX x) = SparsityInterfaceCommon (castForeignPtr x)
-
-
--- helper instances
-instance Marshal MX (Ptr MX') where
-  marshal (MX x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (MX x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__MX" 
-  c_delete_casadi__MX :: FunPtr (Ptr MX' -> IO ())
-instance WrapReturn (Ptr MX') MX where
-  wrapReturn = (fmap MX) . (newForeignPtr c_delete_casadi__MX)
-
-
--- raw decl
-data MXFunction'
--- data decl
-{-|
--}
-newtype MXFunction = MXFunction (ForeignPtr MXFunction')
--- typeclass decl
-class MXFunctionClass a where
-  castMXFunction :: a -> MXFunction
-instance MXFunctionClass MXFunction where
-  castMXFunction = id
-
--- baseclass instances
-instance FunctionClass MXFunction where
-  castFunction (MXFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass MXFunction where
-  castOptionsFunctionality (MXFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass MXFunction where
-  castSharedObject (MXFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass MXFunction where
-  castIOInterfaceFunction (MXFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal MXFunction (Ptr MXFunction') where
-  marshal (MXFunction x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (MXFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__MXFunction" 
-  c_delete_casadi__MXFunction :: FunPtr (Ptr MXFunction' -> IO ())
-instance WrapReturn (Ptr MXFunction') MXFunction where
-  wrapReturn = (fmap MXFunction) . (newForeignPtr c_delete_casadi__MXFunction)
-
-
--- raw decl
-data Map'
--- data decl
-{-|
--}
-newtype Map = Map (ForeignPtr Map')
--- typeclass decl
-class MapClass a where
-  castMap :: a -> Map
-instance MapClass Map where
-  castMap = id
-
--- baseclass instances
-instance FunctionClass Map where
-  castFunction (Map x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Map where
-  castOptionsFunctionality (Map x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass Map where
-  castSharedObject (Map x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Map where
-  castIOInterfaceFunction (Map x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Map (Ptr Map') where
-  marshal (Map x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Map x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Map" 
-  c_delete_casadi__Map :: FunPtr (Ptr Map' -> IO ())
-instance WrapReturn (Ptr Map') Map where
-  wrapReturn = (fmap Map) . (newForeignPtr c_delete_casadi__Map)
-
-
--- raw decl
-data MapAccum'
--- data decl
-{-|
--}
-newtype MapAccum = MapAccum (ForeignPtr MapAccum')
--- typeclass decl
-class MapAccumClass a where
-  castMapAccum :: a -> MapAccum
-instance MapAccumClass MapAccum where
-  castMapAccum = id
-
--- baseclass instances
-instance FunctionClass MapAccum where
-  castFunction (MapAccum x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass MapAccum where
-  castOptionsFunctionality (MapAccum x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass MapAccum where
-  castSharedObject (MapAccum x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass MapAccum where
-  castIOInterfaceFunction (MapAccum x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal MapAccum (Ptr MapAccum') where
-  marshal (MapAccum x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (MapAccum x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__MapAccum" 
-  c_delete_casadi__MapAccum :: FunPtr (Ptr MapAccum' -> IO ())
-instance WrapReturn (Ptr MapAccum') MapAccum where
-  wrapReturn = (fmap MapAccum) . (newForeignPtr c_delete_casadi__MapAccum)
-
-
--- raw decl
-data MatrixCommon'
--- data decl
-{-|
--}
-newtype MatrixCommon = MatrixCommon (ForeignPtr MatrixCommon')
--- typeclass decl
-class MatrixCommonClass a where
-  castMatrixCommon :: a -> MatrixCommon
-instance MatrixCommonClass MatrixCommon where
-  castMatrixCommon = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal MatrixCommon (Ptr MatrixCommon') where
-  marshal (MatrixCommon x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (MatrixCommon x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__MatrixCommon" 
-  c_delete_casadi__MatrixCommon :: FunPtr (Ptr MatrixCommon' -> IO ())
-instance WrapReturn (Ptr MatrixCommon') MatrixCommon where
-  wrapReturn = (fmap MatrixCommon) . (newForeignPtr c_delete_casadi__MatrixCommon)
-
-
--- raw decl
-data NlpBuilder'
--- data decl
-{-|
--}
-newtype NlpBuilder = NlpBuilder (ForeignPtr NlpBuilder')
--- typeclass decl
-class NlpBuilderClass a where
-  castNlpBuilder :: a -> NlpBuilder
-instance NlpBuilderClass NlpBuilder where
-  castNlpBuilder = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal NlpBuilder (Ptr NlpBuilder') where
-  marshal (NlpBuilder x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (NlpBuilder x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__NlpBuilder" 
-  c_delete_casadi__NlpBuilder :: FunPtr (Ptr NlpBuilder' -> IO ())
-instance WrapReturn (Ptr NlpBuilder') NlpBuilder where
-  wrapReturn = (fmap NlpBuilder) . (newForeignPtr c_delete_casadi__NlpBuilder)
-
-
--- raw decl
-data NlpSolver'
--- data decl
-{-|
--}
-newtype NlpSolver = NlpSolver (ForeignPtr NlpSolver')
--- typeclass decl
-class NlpSolverClass a where
-  castNlpSolver :: a -> NlpSolver
-instance NlpSolverClass NlpSolver where
-  castNlpSolver = id
-
--- baseclass instances
-instance FunctionClass NlpSolver where
-  castFunction (NlpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass NlpSolver where
-  castOptionsFunctionality (NlpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass NlpSolver where
-  castSharedObject (NlpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass NlpSolver where
-  castIOInterfaceFunction (NlpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal NlpSolver (Ptr NlpSolver') where
-  marshal (NlpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (NlpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__NlpSolver" 
-  c_delete_casadi__NlpSolver :: FunPtr (Ptr NlpSolver' -> IO ())
-instance WrapReturn (Ptr NlpSolver') NlpSolver where
-  wrapReturn = (fmap NlpSolver) . (newForeignPtr c_delete_casadi__NlpSolver)
-
-
--- raw decl
-data Nullspace'
--- data decl
-{-|
--}
-newtype Nullspace = Nullspace (ForeignPtr Nullspace')
--- typeclass decl
-class NullspaceClass a where
-  castNullspace :: a -> Nullspace
-instance NullspaceClass Nullspace where
-  castNullspace = id
-
--- baseclass instances
-instance FunctionClass Nullspace where
-  castFunction (Nullspace x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Nullspace where
-  castOptionsFunctionality (Nullspace x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass Nullspace where
-  castSharedObject (Nullspace x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Nullspace where
-  castIOInterfaceFunction (Nullspace x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Nullspace (Ptr Nullspace') where
-  marshal (Nullspace x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Nullspace x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Nullspace" 
-  c_delete_casadi__Nullspace :: FunPtr (Ptr Nullspace' -> IO ())
-instance WrapReturn (Ptr Nullspace') Nullspace where
-  wrapReturn = (fmap Nullspace) . (newForeignPtr c_delete_casadi__Nullspace)
-
-
--- raw decl
-data OptionsFunctionality'
--- data decl
-{-|
--}
-newtype OptionsFunctionality = OptionsFunctionality (ForeignPtr OptionsFunctionality')
--- typeclass decl
-class OptionsFunctionalityClass a where
-  castOptionsFunctionality :: a -> OptionsFunctionality
-instance OptionsFunctionalityClass OptionsFunctionality where
-  castOptionsFunctionality = id
-
--- baseclass instances
-instance SharedObjectClass OptionsFunctionality where
-  castSharedObject (OptionsFunctionality x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal OptionsFunctionality (Ptr OptionsFunctionality') where
-  marshal (OptionsFunctionality x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (OptionsFunctionality x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__OptionsFunctionality" 
-  c_delete_casadi__OptionsFunctionality :: FunPtr (Ptr OptionsFunctionality' -> IO ())
-instance WrapReturn (Ptr OptionsFunctionality') OptionsFunctionality where
-  wrapReturn = (fmap OptionsFunctionality) . (newForeignPtr c_delete_casadi__OptionsFunctionality)
-
-
--- raw decl
-data QcqpSolver'
--- data decl
-{-|
--}
-newtype QcqpSolver = QcqpSolver (ForeignPtr QcqpSolver')
--- typeclass decl
-class QcqpSolverClass a where
-  castQcqpSolver :: a -> QcqpSolver
-instance QcqpSolverClass QcqpSolver where
-  castQcqpSolver = id
-
--- baseclass instances
-instance FunctionClass QcqpSolver where
-  castFunction (QcqpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass QcqpSolver where
-  castOptionsFunctionality (QcqpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass QcqpSolver where
-  castSharedObject (QcqpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass QcqpSolver where
-  castIOInterfaceFunction (QcqpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal QcqpSolver (Ptr QcqpSolver') where
-  marshal (QcqpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (QcqpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__QcqpSolver" 
-  c_delete_casadi__QcqpSolver :: FunPtr (Ptr QcqpSolver' -> IO ())
-instance WrapReturn (Ptr QcqpSolver') QcqpSolver where
-  wrapReturn = (fmap QcqpSolver) . (newForeignPtr c_delete_casadi__QcqpSolver)
-
-
--- raw decl
-data QpSolver'
--- data decl
-{-|
--}
-newtype QpSolver = QpSolver (ForeignPtr QpSolver')
--- typeclass decl
-class QpSolverClass a where
-  castQpSolver :: a -> QpSolver
-instance QpSolverClass QpSolver where
-  castQpSolver = id
-
--- baseclass instances
-instance FunctionClass QpSolver where
-  castFunction (QpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass QpSolver where
-  castOptionsFunctionality (QpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass QpSolver where
-  castSharedObject (QpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass QpSolver where
-  castIOInterfaceFunction (QpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal QpSolver (Ptr QpSolver') where
-  marshal (QpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (QpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__QpSolver" 
-  c_delete_casadi__QpSolver :: FunPtr (Ptr QpSolver' -> IO ())
-instance WrapReturn (Ptr QpSolver') QpSolver where
-  wrapReturn = (fmap QpSolver) . (newForeignPtr c_delete_casadi__QpSolver)
-
-
--- raw decl
-data SX'
--- data decl
-{-|
--}
-newtype SX = SX (ForeignPtr SX')
--- typeclass decl
-class SXClass a where
-  castSX :: a -> SX
-instance SXClass SX where
-  castSX = id
-
--- baseclass instances
-instance GenericExpressionCommonClass SX where
-  castGenericExpressionCommon (SX x) = GenericExpressionCommon (castForeignPtr x)
-
-instance GenericMatrixCommonClass SX where
-  castGenericMatrixCommon (SX x) = GenericMatrixCommon (castForeignPtr x)
-
-instance MatrixCommonClass SX where
-  castMatrixCommon (SX x) = MatrixCommon (castForeignPtr x)
-
-instance SparsityInterfaceCommonClass SX where
-  castSparsityInterfaceCommon (SX x) = SparsityInterfaceCommon (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SX (Ptr SX') where
-  marshal (SX x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SX x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SX" 
-  c_delete_casadi__SX :: FunPtr (Ptr SX' -> IO ())
-instance WrapReturn (Ptr SX') SX where
-  wrapReturn = (fmap SX) . (newForeignPtr c_delete_casadi__SX)
-
-
--- raw decl
-data SXElement'
--- data decl
-{-|
--}
-newtype SXElement = SXElement (ForeignPtr SXElement')
--- typeclass decl
-class SXElementClass a where
-  castSXElement :: a -> SXElement
-instance SXElementClass SXElement where
-  castSXElement = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal SXElement (Ptr SXElement') where
-  marshal (SXElement x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SXElement x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SXElement" 
-  c_delete_casadi__SXElement :: FunPtr (Ptr SXElement' -> IO ())
-instance WrapReturn (Ptr SXElement') SXElement where
-  wrapReturn = (fmap SXElement) . (newForeignPtr c_delete_casadi__SXElement)
-
-
--- raw decl
-data SXFunction'
--- data decl
-{-|
--}
-newtype SXFunction = SXFunction (ForeignPtr SXFunction')
--- typeclass decl
-class SXFunctionClass a where
-  castSXFunction :: a -> SXFunction
-instance SXFunctionClass SXFunction where
-  castSXFunction = id
-
--- baseclass instances
-instance FunctionClass SXFunction where
-  castFunction (SXFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SXFunction where
-  castOptionsFunctionality (SXFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass SXFunction where
-  castSharedObject (SXFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SXFunction where
-  castIOInterfaceFunction (SXFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SXFunction (Ptr SXFunction') where
-  marshal (SXFunction x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SXFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SXFunction" 
-  c_delete_casadi__SXFunction :: FunPtr (Ptr SXFunction' -> IO ())
-instance WrapReturn (Ptr SXFunction') SXFunction where
-  wrapReturn = (fmap SXFunction) . (newForeignPtr c_delete_casadi__SXFunction)
-
-
--- raw decl
-data SdpSolver'
--- data decl
-{-|
--}
-newtype SdpSolver = SdpSolver (ForeignPtr SdpSolver')
--- typeclass decl
-class SdpSolverClass a where
-  castSdpSolver :: a -> SdpSolver
-instance SdpSolverClass SdpSolver where
-  castSdpSolver = id
-
--- baseclass instances
-instance FunctionClass SdpSolver where
-  castFunction (SdpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SdpSolver where
-  castOptionsFunctionality (SdpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass SdpSolver where
-  castSharedObject (SdpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SdpSolver where
-  castIOInterfaceFunction (SdpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SdpSolver (Ptr SdpSolver') where
-  marshal (SdpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SdpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SdpSolver" 
-  c_delete_casadi__SdpSolver :: FunPtr (Ptr SdpSolver' -> IO ())
-instance WrapReturn (Ptr SdpSolver') SdpSolver where
-  wrapReturn = (fmap SdpSolver) . (newForeignPtr c_delete_casadi__SdpSolver)
-
-
--- raw decl
-data SdqpSolver'
--- data decl
-{-|
--}
-newtype SdqpSolver = SdqpSolver (ForeignPtr SdqpSolver')
--- typeclass decl
-class SdqpSolverClass a where
-  castSdqpSolver :: a -> SdqpSolver
-instance SdqpSolverClass SdqpSolver where
-  castSdqpSolver = id
-
--- baseclass instances
-instance FunctionClass SdqpSolver where
-  castFunction (SdqpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SdqpSolver where
-  castOptionsFunctionality (SdqpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass SdqpSolver where
-  castSharedObject (SdqpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SdqpSolver where
-  castIOInterfaceFunction (SdqpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SdqpSolver (Ptr SdqpSolver') where
-  marshal (SdqpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SdqpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SdqpSolver" 
-  c_delete_casadi__SdqpSolver :: FunPtr (Ptr SdqpSolver' -> IO ())
-instance WrapReturn (Ptr SdqpSolver') SdqpSolver where
-  wrapReturn = (fmap SdqpSolver) . (newForeignPtr c_delete_casadi__SdqpSolver)
-
-
--- raw decl
-data SharedObject'
--- data decl
-{-|
--}
-newtype SharedObject = SharedObject (ForeignPtr SharedObject')
--- typeclass decl
-class SharedObjectClass a where
-  castSharedObject :: a -> SharedObject
-instance SharedObjectClass SharedObject where
-  castSharedObject = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal SharedObject (Ptr SharedObject') where
-  marshal (SharedObject x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SharedObject x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SharedObject" 
-  c_delete_casadi__SharedObject :: FunPtr (Ptr SharedObject' -> IO ())
-instance WrapReturn (Ptr SharedObject') SharedObject where
-  wrapReturn = (fmap SharedObject) . (newForeignPtr c_delete_casadi__SharedObject)
-
-
--- raw decl
-data Simulator'
--- data decl
-{-|
--}
-newtype Simulator = Simulator (ForeignPtr Simulator')
--- typeclass decl
-class SimulatorClass a where
-  castSimulator :: a -> Simulator
-instance SimulatorClass Simulator where
-  castSimulator = id
-
--- baseclass instances
-instance FunctionClass Simulator where
-  castFunction (Simulator x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Simulator where
-  castOptionsFunctionality (Simulator x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass Simulator where
-  castSharedObject (Simulator x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Simulator where
-  castIOInterfaceFunction (Simulator x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Simulator (Ptr Simulator') where
-  marshal (Simulator x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Simulator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Simulator" 
-  c_delete_casadi__Simulator :: FunPtr (Ptr Simulator' -> IO ())
-instance WrapReturn (Ptr Simulator') Simulator where
-  wrapReturn = (fmap Simulator) . (newForeignPtr c_delete_casadi__Simulator)
-
-
--- raw decl
-data Slice'
--- data decl
-{-|
--}
-newtype Slice = Slice (ForeignPtr Slice')
--- typeclass decl
-class SliceClass a where
-  castSlice :: a -> Slice
-instance SliceClass Slice where
-  castSlice = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal Slice (Ptr Slice') where
-  marshal (Slice x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Slice x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Slice" 
-  c_delete_casadi__Slice :: FunPtr (Ptr Slice' -> IO ())
-instance WrapReturn (Ptr Slice') Slice where
-  wrapReturn = (fmap Slice) . (newForeignPtr c_delete_casadi__Slice)
-
-
--- raw decl
-data SocpSolver'
--- data decl
-{-|
--}
-newtype SocpSolver = SocpSolver (ForeignPtr SocpSolver')
--- typeclass decl
-class SocpSolverClass a where
-  castSocpSolver :: a -> SocpSolver
-instance SocpSolverClass SocpSolver where
-  castSocpSolver = id
-
--- baseclass instances
-instance FunctionClass SocpSolver where
-  castFunction (SocpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SocpSolver where
-  castOptionsFunctionality (SocpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass SocpSolver where
-  castSharedObject (SocpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SocpSolver where
-  castIOInterfaceFunction (SocpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SocpSolver (Ptr SocpSolver') where
-  marshal (SocpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SocpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SocpSolver" 
-  c_delete_casadi__SocpSolver :: FunPtr (Ptr SocpSolver' -> IO ())
-instance WrapReturn (Ptr SocpSolver') SocpSolver where
-  wrapReturn = (fmap SocpSolver) . (newForeignPtr c_delete_casadi__SocpSolver)
-
-
--- raw decl
-data Sparsity'
--- data decl
-{-|
--}
-newtype Sparsity = Sparsity (ForeignPtr Sparsity')
--- typeclass decl
-class SparsityClass a where
-  castSparsity :: a -> Sparsity
-instance SparsityClass Sparsity where
-  castSparsity = id
-
--- baseclass instances
-instance SharedObjectClass Sparsity where
-  castSharedObject (Sparsity x) = SharedObject (castForeignPtr x)
-
-instance SparsityInterfaceCommonClass Sparsity where
-  castSparsityInterfaceCommon (Sparsity x) = SparsityInterfaceCommon (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Sparsity (Ptr Sparsity') where
-  marshal (Sparsity x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Sparsity x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Sparsity" 
-  c_delete_casadi__Sparsity :: FunPtr (Ptr Sparsity' -> IO ())
-instance WrapReturn (Ptr Sparsity') Sparsity where
-  wrapReturn = (fmap Sparsity) . (newForeignPtr c_delete_casadi__Sparsity)
-
-
--- raw decl
-data SparsityInterfaceCommon'
--- data decl
-{-|
--}
-newtype SparsityInterfaceCommon = SparsityInterfaceCommon (ForeignPtr SparsityInterfaceCommon')
--- typeclass decl
-class SparsityInterfaceCommonClass a where
-  castSparsityInterfaceCommon :: a -> SparsityInterfaceCommon
-instance SparsityInterfaceCommonClass SparsityInterfaceCommon where
-  castSparsityInterfaceCommon = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal SparsityInterfaceCommon (Ptr SparsityInterfaceCommon') where
-  marshal (SparsityInterfaceCommon x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SparsityInterfaceCommon x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SparsityInterfaceCommon" 
-  c_delete_casadi__SparsityInterfaceCommon :: FunPtr (Ptr SparsityInterfaceCommon' -> IO ())
-instance WrapReturn (Ptr SparsityInterfaceCommon') SparsityInterfaceCommon where
-  wrapReturn = (fmap SparsityInterfaceCommon) . (newForeignPtr c_delete_casadi__SparsityInterfaceCommon)
-
-
--- raw decl
-data StabilizedQpSolver'
--- data decl
-{-|
--}
-newtype StabilizedQpSolver = StabilizedQpSolver (ForeignPtr StabilizedQpSolver')
--- typeclass decl
-class StabilizedQpSolverClass a where
-  castStabilizedQpSolver :: a -> StabilizedQpSolver
-instance StabilizedQpSolverClass StabilizedQpSolver where
-  castStabilizedQpSolver = id
-
--- baseclass instances
-instance FunctionClass StabilizedQpSolver where
-  castFunction (StabilizedQpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass StabilizedQpSolver where
-  castOptionsFunctionality (StabilizedQpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass StabilizedQpSolver where
-  castSharedObject (StabilizedQpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass StabilizedQpSolver where
-  castIOInterfaceFunction (StabilizedQpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal StabilizedQpSolver (Ptr StabilizedQpSolver') where
-  marshal (StabilizedQpSolver x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (StabilizedQpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__StabilizedQpSolver" 
-  c_delete_casadi__StabilizedQpSolver :: FunPtr (Ptr StabilizedQpSolver' -> IO ())
-instance WrapReturn (Ptr StabilizedQpSolver') StabilizedQpSolver where
-  wrapReturn = (fmap StabilizedQpSolver) . (newForeignPtr c_delete_casadi__StabilizedQpSolver)
-
-
--- raw decl
-data Switch'
--- data decl
-{-|
--}
-newtype Switch = Switch (ForeignPtr Switch')
--- typeclass decl
-class SwitchClass a where
-  castSwitch :: a -> Switch
-instance SwitchClass Switch where
-  castSwitch = id
-
--- baseclass instances
-instance FunctionClass Switch where
-  castFunction (Switch x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Switch where
-  castOptionsFunctionality (Switch x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass Switch where
-  castSharedObject (Switch x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Switch where
-  castIOInterfaceFunction (Switch x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Switch (Ptr Switch') where
-  marshal (Switch x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Switch x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Switch" 
-  c_delete_casadi__Switch :: FunPtr (Ptr Switch' -> IO ())
-instance WrapReturn (Ptr Switch') Switch where
-  wrapReturn = (fmap Switch) . (newForeignPtr c_delete_casadi__Switch)
-
-
--- raw decl
-data Variable'
--- data decl
-{-|
--}
-newtype Variable = Variable (ForeignPtr Variable')
--- typeclass decl
-class VariableClass a where
-  castVariable :: a -> Variable
-instance VariableClass Variable where
-  castVariable = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal Variable (Ptr Variable') where
-  marshal (Variable x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (Variable x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Variable" 
-  c_delete_casadi__Variable :: FunPtr (Ptr Variable' -> IO ())
-instance WrapReturn (Ptr Variable') Variable where
-  wrapReturn = (fmap Variable) . (newForeignPtr c_delete_casadi__Variable)
-
-
--- raw decl
-data XmlFile'
--- data decl
-{-|
--}
-newtype XmlFile = XmlFile (ForeignPtr XmlFile')
--- typeclass decl
-class XmlFileClass a where
-  castXmlFile :: a -> XmlFile
-instance XmlFileClass XmlFile where
-  castXmlFile = id
-
--- baseclass instances
-instance OptionsFunctionalityClass XmlFile where
-  castOptionsFunctionality (XmlFile x) = OptionsFunctionality (castForeignPtr x)
-
-instance SharedObjectClass XmlFile where
-  castSharedObject (XmlFile x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal XmlFile (Ptr XmlFile') where
-  marshal (XmlFile x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (XmlFile x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__XmlFile" 
-  c_delete_casadi__XmlFile :: FunPtr (Ptr XmlFile' -> IO ())
-instance WrapReturn (Ptr XmlFile') XmlFile where
-  wrapReturn = (fmap XmlFile) . (newForeignPtr c_delete_casadi__XmlFile)
-
-
--- raw decl
-data IOInterfaceFunction'
--- data decl
-{-|
--}
-newtype IOInterfaceFunction = IOInterfaceFunction (ForeignPtr IOInterfaceFunction')
--- typeclass decl
-class IOInterfaceFunctionClass a where
-  castIOInterfaceFunction :: a -> IOInterfaceFunction
-instance IOInterfaceFunctionClass IOInterfaceFunction where
-  castIOInterfaceFunction = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal IOInterfaceFunction (Ptr IOInterfaceFunction') where
-  marshal (IOInterfaceFunction x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (IOInterfaceFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__IOInterface_casadi__Function_" 
-  c_delete_casadi__IOInterface_casadi__Function_ :: FunPtr (Ptr IOInterfaceFunction' -> IO ())
-instance WrapReturn (Ptr IOInterfaceFunction') IOInterfaceFunction where
-  wrapReturn = (fmap IOInterfaceFunction) . (newForeignPtr c_delete_casadi__IOInterface_casadi__Function_)
+instance FunctionClass Callback where
+  castFunction (Callback x) = Function (castForeignPtr x)
+
+instance SharedObjectClass Callback where
+  castSharedObject (Callback x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Callback (Ptr Callback') where
+  marshal (Callback x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (Callback x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Callback" 
+  c_delete_casadi__Callback :: FunPtr (Ptr Callback' -> IO ())
+instance WrapReturn (Ptr Callback') Callback where
+  wrapReturn = (fmap Callback) . (newForeignPtr c_delete_casadi__Callback)
+
+
+-- raw decl
+data CasadiMeta'
+-- data decl
+{-|
+-}
+newtype CasadiMeta = CasadiMeta (ForeignPtr CasadiMeta')
+-- typeclass decl
+class CasadiMetaClass a where
+  castCasadiMeta :: a -> CasadiMeta
+instance CasadiMetaClass CasadiMeta where
+  castCasadiMeta = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal CasadiMeta (Ptr CasadiMeta') where
+  marshal (CasadiMeta x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (CasadiMeta x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__CasadiMeta" 
+  c_delete_casadi__CasadiMeta :: FunPtr (Ptr CasadiMeta' -> IO ())
+instance WrapReturn (Ptr CasadiMeta') CasadiMeta where
+  wrapReturn = (fmap CasadiMeta) . (newForeignPtr c_delete_casadi__CasadiMeta)
+
+
+-- raw decl
+data CodeGenerator'
+-- data decl
+{-|
+-}
+newtype CodeGenerator = CodeGenerator (ForeignPtr CodeGenerator')
+-- typeclass decl
+class CodeGeneratorClass a where
+  castCodeGenerator :: a -> CodeGenerator
+instance CodeGeneratorClass CodeGenerator where
+  castCodeGenerator = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal CodeGenerator (Ptr CodeGenerator') where
+  marshal (CodeGenerator x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (CodeGenerator x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__CodeGenerator" 
+  c_delete_casadi__CodeGenerator :: FunPtr (Ptr CodeGenerator' -> IO ())
+instance WrapReturn (Ptr CodeGenerator') CodeGenerator where
+  wrapReturn = (fmap CodeGenerator) . (newForeignPtr c_delete_casadi__CodeGenerator)
+
+
+-- raw decl
+data Compiler'
+-- data decl
+{-|
+-}
+newtype Compiler = Compiler (ForeignPtr Compiler')
+-- typeclass decl
+class CompilerClass a where
+  castCompiler :: a -> Compiler
+instance CompilerClass Compiler where
+  castCompiler = id
+
+-- baseclass instances
+instance SharedObjectClass Compiler where
+  castSharedObject (Compiler x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Compiler (Ptr Compiler') where
+  marshal (Compiler x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (Compiler x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Compiler" 
+  c_delete_casadi__Compiler :: FunPtr (Ptr Compiler' -> IO ())
+instance WrapReturn (Ptr Compiler') Compiler where
+  wrapReturn = (fmap Compiler) . (newForeignPtr c_delete_casadi__Compiler)
+
+
+-- raw decl
+data DM'
+-- data decl
+{-|
+-}
+newtype DM = DM (ForeignPtr DM')
+-- typeclass decl
+class DMClass a where
+  castDM :: a -> DM
+instance DMClass DM where
+  castDM = id
+
+-- baseclass instances
+instance GenericExpressionCommonClass DM where
+  castGenericExpressionCommon (DM x) = GenericExpressionCommon (castForeignPtr x)
+
+instance GenericMatrixCommonClass DM where
+  castGenericMatrixCommon (DM x) = GenericMatrixCommon (castForeignPtr x)
+
+instance MatrixCommonClass DM where
+  castMatrixCommon (DM x) = MatrixCommon (castForeignPtr x)
+
+instance SparsityInterfaceCommonClass DM where
+  castSparsityInterfaceCommon (DM x) = SparsityInterfaceCommon (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal DM (Ptr DM') where
+  marshal (DM x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (DM x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__DM" 
+  c_delete_casadi__DM :: FunPtr (Ptr DM' -> IO ())
+instance WrapReturn (Ptr DM') DM where
+  wrapReturn = (fmap DM) . (newForeignPtr c_delete_casadi__DM)
+
+
+-- raw decl
+data DaeBuilder'
+-- data decl
+{-|
+-}
+newtype DaeBuilder = DaeBuilder (ForeignPtr DaeBuilder')
+-- typeclass decl
+class DaeBuilderClass a where
+  castDaeBuilder :: a -> DaeBuilder
+instance DaeBuilderClass DaeBuilder where
+  castDaeBuilder = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal DaeBuilder (Ptr DaeBuilder') where
+  marshal (DaeBuilder x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (DaeBuilder x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__DaeBuilder" 
+  c_delete_casadi__DaeBuilder :: FunPtr (Ptr DaeBuilder' -> IO ())
+instance WrapReturn (Ptr DaeBuilder') DaeBuilder where
+  wrapReturn = (fmap DaeBuilder) . (newForeignPtr c_delete_casadi__DaeBuilder)
+
+
+-- raw decl
+data Function'
+-- data decl
+{-|
+-}
+newtype Function = Function (ForeignPtr Function')
+-- typeclass decl
+class FunctionClass a where
+  castFunction :: a -> Function
+instance FunctionClass Function where
+  castFunction = id
+
+-- baseclass instances
+instance SharedObjectClass Function where
+  castSharedObject (Function x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Function (Ptr Function') where
+  marshal (Function x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (Function x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Function" 
+  c_delete_casadi__Function :: FunPtr (Ptr Function' -> IO ())
+instance WrapReturn (Ptr Function') Function where
+  wrapReturn = (fmap Function) . (newForeignPtr c_delete_casadi__Function)
+
+
+-- raw decl
+data GenericExpressionCommon'
+-- data decl
+{-|
+-}
+newtype GenericExpressionCommon = GenericExpressionCommon (ForeignPtr GenericExpressionCommon')
+-- typeclass decl
+class GenericExpressionCommonClass a where
+  castGenericExpressionCommon :: a -> GenericExpressionCommon
+instance GenericExpressionCommonClass GenericExpressionCommon where
+  castGenericExpressionCommon = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal GenericExpressionCommon (Ptr GenericExpressionCommon') where
+  marshal (GenericExpressionCommon x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (GenericExpressionCommon x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__GenericExpressionCommon" 
+  c_delete_casadi__GenericExpressionCommon :: FunPtr (Ptr GenericExpressionCommon' -> IO ())
+instance WrapReturn (Ptr GenericExpressionCommon') GenericExpressionCommon where
+  wrapReturn = (fmap GenericExpressionCommon) . (newForeignPtr c_delete_casadi__GenericExpressionCommon)
+
+
+-- raw decl
+data GenericMatrixCommon'
+-- data decl
+{-|
+-}
+newtype GenericMatrixCommon = GenericMatrixCommon (ForeignPtr GenericMatrixCommon')
+-- typeclass decl
+class GenericMatrixCommonClass a where
+  castGenericMatrixCommon :: a -> GenericMatrixCommon
+instance GenericMatrixCommonClass GenericMatrixCommon where
+  castGenericMatrixCommon = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal GenericMatrixCommon (Ptr GenericMatrixCommon') where
+  marshal (GenericMatrixCommon x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (GenericMatrixCommon x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__GenericMatrixCommon" 
+  c_delete_casadi__GenericMatrixCommon :: FunPtr (Ptr GenericMatrixCommon' -> IO ())
+instance WrapReturn (Ptr GenericMatrixCommon') GenericMatrixCommon where
+  wrapReturn = (fmap GenericMatrixCommon) . (newForeignPtr c_delete_casadi__GenericMatrixCommon)
+
+
+-- raw decl
+data GenericType'
+-- data decl
+{-|
+-}
+newtype GenericType = GenericType (ForeignPtr GenericType')
+-- typeclass decl
+class GenericTypeClass a where
+  castGenericType :: a -> GenericType
+instance GenericTypeClass GenericType where
+  castGenericType = id
+
+-- baseclass instances
+instance SharedObjectClass GenericType where
+  castSharedObject (GenericType x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal GenericType (Ptr GenericType') where
+  marshal (GenericType x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (GenericType x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__GenericType" 
+  c_delete_casadi__GenericType :: FunPtr (Ptr GenericType' -> IO ())
+instance WrapReturn (Ptr GenericType') GenericType where
+  wrapReturn = (fmap GenericType) . (newForeignPtr c_delete_casadi__GenericType)
+
+
+-- raw decl
+data GlobalOptions'
+-- data decl
+{-|
+-}
+newtype GlobalOptions = GlobalOptions (ForeignPtr GlobalOptions')
+-- typeclass decl
+class GlobalOptionsClass a where
+  castGlobalOptions :: a -> GlobalOptions
+instance GlobalOptionsClass GlobalOptions where
+  castGlobalOptions = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal GlobalOptions (Ptr GlobalOptions') where
+  marshal (GlobalOptions x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (GlobalOptions x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__GlobalOptions" 
+  c_delete_casadi__GlobalOptions :: FunPtr (Ptr GlobalOptions' -> IO ())
+instance WrapReturn (Ptr GlobalOptions') GlobalOptions where
+  wrapReturn = (fmap GlobalOptions) . (newForeignPtr c_delete_casadi__GlobalOptions)
+
+
+-- raw decl
+data IM'
+-- data decl
+{-|
+-}
+newtype IM = IM (ForeignPtr IM')
+-- typeclass decl
+class IMClass a where
+  castIM :: a -> IM
+instance IMClass IM where
+  castIM = id
+
+-- baseclass instances
+instance GenericExpressionCommonClass IM where
+  castGenericExpressionCommon (IM x) = GenericExpressionCommon (castForeignPtr x)
+
+instance GenericMatrixCommonClass IM where
+  castGenericMatrixCommon (IM x) = GenericMatrixCommon (castForeignPtr x)
+
+instance MatrixCommonClass IM where
+  castMatrixCommon (IM x) = MatrixCommon (castForeignPtr x)
+
+instance SparsityInterfaceCommonClass IM where
+  castSparsityInterfaceCommon (IM x) = SparsityInterfaceCommon (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal IM (Ptr IM') where
+  marshal (IM x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (IM x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__IM" 
+  c_delete_casadi__IM :: FunPtr (Ptr IM' -> IO ())
+instance WrapReturn (Ptr IM') IM where
+  wrapReturn = (fmap IM) . (newForeignPtr c_delete_casadi__IM)
+
+
+-- raw decl
+data Library'
+-- data decl
+{-|
+-}
+newtype Library = Library (ForeignPtr Library')
+-- typeclass decl
+class LibraryClass a where
+  castLibrary :: a -> Library
+instance LibraryClass Library where
+  castLibrary = id
+
+-- baseclass instances
+instance SharedObjectClass Library where
+  castSharedObject (Library x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Library (Ptr Library') where
+  marshal (Library x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (Library x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Library" 
+  c_delete_casadi__Library :: FunPtr (Ptr Library' -> IO ())
+instance WrapReturn (Ptr Library') Library where
+  wrapReturn = (fmap Library) . (newForeignPtr c_delete_casadi__Library)
+
+
+-- raw decl
+data MX'
+-- data decl
+{-|
+-}
+newtype MX = MX (ForeignPtr MX')
+-- typeclass decl
+class MXClass a where
+  castMX :: a -> MX
+instance MXClass MX where
+  castMX = id
+
+-- baseclass instances
+instance GenericExpressionCommonClass MX where
+  castGenericExpressionCommon (MX x) = GenericExpressionCommon (castForeignPtr x)
+
+instance GenericMatrixCommonClass MX where
+  castGenericMatrixCommon (MX x) = GenericMatrixCommon (castForeignPtr x)
+
+instance SharedObjectClass MX where
+  castSharedObject (MX x) = SharedObject (castForeignPtr x)
+
+instance SparsityInterfaceCommonClass MX where
+  castSparsityInterfaceCommon (MX x) = SparsityInterfaceCommon (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal MX (Ptr MX') where
+  marshal (MX x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (MX x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__MX" 
+  c_delete_casadi__MX :: FunPtr (Ptr MX' -> IO ())
+instance WrapReturn (Ptr MX') MX where
+  wrapReturn = (fmap MX) . (newForeignPtr c_delete_casadi__MX)
+
+
+-- raw decl
+data MatrixCommon'
+-- data decl
+{-|
+-}
+newtype MatrixCommon = MatrixCommon (ForeignPtr MatrixCommon')
+-- typeclass decl
+class MatrixCommonClass a where
+  castMatrixCommon :: a -> MatrixCommon
+instance MatrixCommonClass MatrixCommon where
+  castMatrixCommon = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal MatrixCommon (Ptr MatrixCommon') where
+  marshal (MatrixCommon x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (MatrixCommon x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__MatrixCommon" 
+  c_delete_casadi__MatrixCommon :: FunPtr (Ptr MatrixCommon' -> IO ())
+instance WrapReturn (Ptr MatrixCommon') MatrixCommon where
+  wrapReturn = (fmap MatrixCommon) . (newForeignPtr c_delete_casadi__MatrixCommon)
+
+
+-- raw decl
+data NlpBuilder'
+-- data decl
+{-|
+-}
+newtype NlpBuilder = NlpBuilder (ForeignPtr NlpBuilder')
+-- typeclass decl
+class NlpBuilderClass a where
+  castNlpBuilder :: a -> NlpBuilder
+instance NlpBuilderClass NlpBuilder where
+  castNlpBuilder = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal NlpBuilder (Ptr NlpBuilder') where
+  marshal (NlpBuilder x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (NlpBuilder x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__NlpBuilder" 
+  c_delete_casadi__NlpBuilder :: FunPtr (Ptr NlpBuilder' -> IO ())
+instance WrapReturn (Ptr NlpBuilder') NlpBuilder where
+  wrapReturn = (fmap NlpBuilder) . (newForeignPtr c_delete_casadi__NlpBuilder)
+
+
+-- raw decl
+data SX'
+-- data decl
+{-|
+-}
+newtype SX = SX (ForeignPtr SX')
+-- typeclass decl
+class SXClass a where
+  castSX :: a -> SX
+instance SXClass SX where
+  castSX = id
+
+-- baseclass instances
+instance GenericExpressionCommonClass SX where
+  castGenericExpressionCommon (SX x) = GenericExpressionCommon (castForeignPtr x)
+
+instance GenericMatrixCommonClass SX where
+  castGenericMatrixCommon (SX x) = GenericMatrixCommon (castForeignPtr x)
+
+instance MatrixCommonClass SX where
+  castMatrixCommon (SX x) = MatrixCommon (castForeignPtr x)
+
+instance SparsityInterfaceCommonClass SX where
+  castSparsityInterfaceCommon (SX x) = SparsityInterfaceCommon (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal SX (Ptr SX') where
+  marshal (SX x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (SX x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SX" 
+  c_delete_casadi__SX :: FunPtr (Ptr SX' -> IO ())
+instance WrapReturn (Ptr SX') SX where
+  wrapReturn = (fmap SX) . (newForeignPtr c_delete_casadi__SX)
+
+
+-- raw decl
+data SXElem'
+-- data decl
+{-|
+-}
+newtype SXElem = SXElem (ForeignPtr SXElem')
+-- typeclass decl
+class SXElemClass a where
+  castSXElem :: a -> SXElem
+instance SXElemClass SXElem where
+  castSXElem = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal SXElem (Ptr SXElem') where
+  marshal (SXElem x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (SXElem x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SXElem" 
+  c_delete_casadi__SXElem :: FunPtr (Ptr SXElem' -> IO ())
+instance WrapReturn (Ptr SXElem') SXElem where
+  wrapReturn = (fmap SXElem) . (newForeignPtr c_delete_casadi__SXElem)
+
+
+-- raw decl
+data SharedObject'
+-- data decl
+{-|
+-}
+newtype SharedObject = SharedObject (ForeignPtr SharedObject')
+-- typeclass decl
+class SharedObjectClass a where
+  castSharedObject :: a -> SharedObject
+instance SharedObjectClass SharedObject where
+  castSharedObject = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal SharedObject (Ptr SharedObject') where
+  marshal (SharedObject x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (SharedObject x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SharedObject" 
+  c_delete_casadi__SharedObject :: FunPtr (Ptr SharedObject' -> IO ())
+instance WrapReturn (Ptr SharedObject') SharedObject where
+  wrapReturn = (fmap SharedObject) . (newForeignPtr c_delete_casadi__SharedObject)
+
+
+-- raw decl
+data Slice'
+-- data decl
+{-|
+-}
+newtype Slice = Slice (ForeignPtr Slice')
+-- typeclass decl
+class SliceClass a where
+  castSlice :: a -> Slice
+instance SliceClass Slice where
+  castSlice = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal Slice (Ptr Slice') where
+  marshal (Slice x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (Slice x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Slice" 
+  c_delete_casadi__Slice :: FunPtr (Ptr Slice' -> IO ())
+instance WrapReturn (Ptr Slice') Slice where
+  wrapReturn = (fmap Slice) . (newForeignPtr c_delete_casadi__Slice)
+
+
+-- raw decl
+data Sparsity'
+-- data decl
+{-|
+-}
+newtype Sparsity = Sparsity (ForeignPtr Sparsity')
+-- typeclass decl
+class SparsityClass a where
+  castSparsity :: a -> Sparsity
+instance SparsityClass Sparsity where
+  castSparsity = id
+
+-- baseclass instances
+instance SharedObjectClass Sparsity where
+  castSharedObject (Sparsity x) = SharedObject (castForeignPtr x)
+
+instance SparsityInterfaceCommonClass Sparsity where
+  castSparsityInterfaceCommon (Sparsity x) = SparsityInterfaceCommon (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Sparsity (Ptr Sparsity') where
+  marshal (Sparsity x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (Sparsity x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Sparsity" 
+  c_delete_casadi__Sparsity :: FunPtr (Ptr Sparsity' -> IO ())
+instance WrapReturn (Ptr Sparsity') Sparsity where
+  wrapReturn = (fmap Sparsity) . (newForeignPtr c_delete_casadi__Sparsity)
+
+
+-- raw decl
+data SparsityInterfaceCommon'
+-- data decl
+{-|
+-}
+newtype SparsityInterfaceCommon = SparsityInterfaceCommon (ForeignPtr SparsityInterfaceCommon')
+-- typeclass decl
+class SparsityInterfaceCommonClass a where
+  castSparsityInterfaceCommon :: a -> SparsityInterfaceCommon
+instance SparsityInterfaceCommonClass SparsityInterfaceCommon where
+  castSparsityInterfaceCommon = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal SparsityInterfaceCommon (Ptr SparsityInterfaceCommon') where
+  marshal (SparsityInterfaceCommon x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (SparsityInterfaceCommon x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SparsityInterfaceCommon" 
+  c_delete_casadi__SparsityInterfaceCommon :: FunPtr (Ptr SparsityInterfaceCommon' -> IO ())
+instance WrapReturn (Ptr SparsityInterfaceCommon') SparsityInterfaceCommon where
+  wrapReturn = (fmap SparsityInterfaceCommon) . (newForeignPtr c_delete_casadi__SparsityInterfaceCommon)
+
+
+-- raw decl
+data Variable'
+-- data decl
+{-|
+-}
+newtype Variable = Variable (ForeignPtr Variable')
+-- typeclass decl
+class VariableClass a where
+  castVariable :: a -> Variable
+instance VariableClass Variable where
+  castVariable = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal Variable (Ptr Variable') where
+  marshal (Variable x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (Variable x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Variable" 
+  c_delete_casadi__Variable :: FunPtr (Ptr Variable' -> IO ())
+instance WrapReturn (Ptr Variable') Variable where
+  wrapReturn = (fmap Variable) . (newForeignPtr c_delete_casadi__Variable)
+
+
+-- raw decl
+data XmlFile'
+-- data decl
+{-|
+-}
+newtype XmlFile = XmlFile (ForeignPtr XmlFile')
+-- typeclass decl
+class XmlFileClass a where
+  castXmlFile :: a -> XmlFile
+instance XmlFileClass XmlFile where
+  castXmlFile = id
+
+-- baseclass instances
+instance SharedObjectClass XmlFile where
+  castSharedObject (XmlFile x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal XmlFile (Ptr XmlFile') where
+  marshal (XmlFile x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (XmlFile x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__XmlFile" 
+  c_delete_casadi__XmlFile :: FunPtr (Ptr XmlFile' -> IO ())
+instance WrapReturn (Ptr XmlFile') XmlFile where
+  wrapReturn = (fmap XmlFile) . (newForeignPtr c_delete_casadi__XmlFile)
 
 
diff --git a/Casadi/Core/Enums.hs b/Casadi/Core/Enums.hs
--- a/Casadi/Core/Enums.hs
+++ b/Casadi/Core/Enums.hs
@@ -9,7 +9,6 @@
          Causality(..),
          CollocationPoints(..),
          Dynamics(..),
-         InputOutputScheme(..),
          Operation(..),
          TypeID(..),
          Variability(..),
@@ -125,155 +124,8 @@
 instance WrapReturn CInt Dynamics where
         wrapReturn = return . toEnum . fromIntegral
 
--- EnumDecl: InputOutputScheme
-data InputOutputScheme = SCHEME_CLEInput
-                       | SCHEME_CLEOutput
-                       | SCHEME_ControlSimulatorInput
-                       | SCHEME_ControlledDAEInput
-                       | SCHEME_DAEInput
-                       | SCHEME_DAEOutput
-                       | SCHEME_DLEInput
-                       | SCHEME_DLEOutput
-                       | SCHEME_DPLEInput
-                       | SCHEME_DPLEOutput
-                       | SCHEME_GradFInput
-                       | SCHEME_GradFOutput
-                       | SCHEME_HNLPInput
-                       | SCHEME_HessLagInput
-                       | SCHEME_HessLagOutput
-                       | SCHEME_IntegratorInput
-                       | SCHEME_IntegratorOutput
-                       | SCHEME_JacGInput
-                       | SCHEME_JacGOutput
-                       | SCHEME_LR_DLEInput
-                       | SCHEME_LR_DLEOutput
-                       | SCHEME_LR_DPLEInput
-                       | SCHEME_LR_DPLEOutput
-                       | SCHEME_LinsolInput
-                       | SCHEME_LinsolOutput
-                       | SCHEME_LpSolverInput
-                       | SCHEME_LpSolverOutput
-                       | SCHEME_NLPInput
-                       | SCHEME_NLPOutput
-                       | SCHEME_NlpSolverInput
-                       | SCHEME_NlpSolverOutput
-                       | SCHEME_QcqpSolverInput
-                       | SCHEME_QcqpSolverOutput
-                       | SCHEME_QpSolverInput
-                       | SCHEME_QpSolverOutput
-                       | SCHEME_RDAEInput
-                       | SCHEME_RDAEOutput
-                       | SCHEME_SDPInput
-                       | SCHEME_SDPOutput
-                       | SCHEME_SDQPInput
-                       | SCHEME_SDQPOutput
-                       | SCHEME_SOCPInput
-                       | SCHEME_SOCPOutput
-                       | SCHEME_SOCPStruct
-                       | SCHEME_StabilizedQpSolverInput
-                       deriving (Show, Eq)
-instance Enum InputOutputScheme where
-        fromEnum (SCHEME_CLEInput) = 0
-        fromEnum (SCHEME_CLEOutput) = 1
-        fromEnum (SCHEME_ControlSimulatorInput) = 3
-        fromEnum (SCHEME_ControlledDAEInput) = 2
-        fromEnum (SCHEME_DAEInput) = 9
-        fromEnum (SCHEME_DAEOutput) = 10
-        fromEnum (SCHEME_DLEInput) = 4
-        fromEnum (SCHEME_DLEOutput) = 5
-        fromEnum (SCHEME_DPLEInput) = 6
-        fromEnum (SCHEME_DPLEOutput) = 7
-        fromEnum (SCHEME_GradFInput) = 25
-        fromEnum (SCHEME_GradFOutput) = 26
-        fromEnum (SCHEME_HNLPInput) = 8
-        fromEnum (SCHEME_HessLagInput) = 29
-        fromEnum (SCHEME_HessLagOutput) = 30
-        fromEnum (SCHEME_IntegratorInput) = 13
-        fromEnum (SCHEME_IntegratorOutput) = 14
-        fromEnum (SCHEME_JacGInput) = 27
-        fromEnum (SCHEME_JacGOutput) = 28
-        fromEnum (SCHEME_LR_DLEInput) = 19
-        fromEnum (SCHEME_LR_DLEOutput) = 20
-        fromEnum (SCHEME_LR_DPLEInput) = 21
-        fromEnum (SCHEME_LR_DPLEOutput) = 22
-        fromEnum (SCHEME_LinsolInput) = 15
-        fromEnum (SCHEME_LinsolOutput) = 16
-        fromEnum (SCHEME_LpSolverInput) = 17
-        fromEnum (SCHEME_LpSolverOutput) = 18
-        fromEnum (SCHEME_NLPInput) = 23
-        fromEnum (SCHEME_NLPOutput) = 24
-        fromEnum (SCHEME_NlpSolverInput) = 31
-        fromEnum (SCHEME_NlpSolverOutput) = 32
-        fromEnum (SCHEME_QcqpSolverInput) = 33
-        fromEnum (SCHEME_QcqpSolverOutput) = 34
-        fromEnum (SCHEME_QpSolverInput) = 35
-        fromEnum (SCHEME_QpSolverOutput) = 36
-        fromEnum (SCHEME_RDAEInput) = 11
-        fromEnum (SCHEME_RDAEOutput) = 12
-        fromEnum (SCHEME_SDPInput) = 37
-        fromEnum (SCHEME_SDPOutput) = 38
-        fromEnum (SCHEME_SDQPInput) = 39
-        fromEnum (SCHEME_SDQPOutput) = 40
-        fromEnum (SCHEME_SOCPInput) = 41
-        fromEnum (SCHEME_SOCPOutput) = 42
-        fromEnum (SCHEME_SOCPStruct) = 43
-        fromEnum (SCHEME_StabilizedQpSolverInput) = 44
-        toEnum (0) = SCHEME_CLEInput
-        toEnum (1) = SCHEME_CLEOutput
-        toEnum (3) = SCHEME_ControlSimulatorInput
-        toEnum (2) = SCHEME_ControlledDAEInput
-        toEnum (9) = SCHEME_DAEInput
-        toEnum (10) = SCHEME_DAEOutput
-        toEnum (4) = SCHEME_DLEInput
-        toEnum (5) = SCHEME_DLEOutput
-        toEnum (6) = SCHEME_DPLEInput
-        toEnum (7) = SCHEME_DPLEOutput
-        toEnum (25) = SCHEME_GradFInput
-        toEnum (26) = SCHEME_GradFOutput
-        toEnum (8) = SCHEME_HNLPInput
-        toEnum (29) = SCHEME_HessLagInput
-        toEnum (30) = SCHEME_HessLagOutput
-        toEnum (13) = SCHEME_IntegratorInput
-        toEnum (14) = SCHEME_IntegratorOutput
-        toEnum (27) = SCHEME_JacGInput
-        toEnum (28) = SCHEME_JacGOutput
-        toEnum (19) = SCHEME_LR_DLEInput
-        toEnum (20) = SCHEME_LR_DLEOutput
-        toEnum (21) = SCHEME_LR_DPLEInput
-        toEnum (22) = SCHEME_LR_DPLEOutput
-        toEnum (15) = SCHEME_LinsolInput
-        toEnum (16) = SCHEME_LinsolOutput
-        toEnum (17) = SCHEME_LpSolverInput
-        toEnum (18) = SCHEME_LpSolverOutput
-        toEnum (23) = SCHEME_NLPInput
-        toEnum (24) = SCHEME_NLPOutput
-        toEnum (31) = SCHEME_NlpSolverInput
-        toEnum (32) = SCHEME_NlpSolverOutput
-        toEnum (33) = SCHEME_QcqpSolverInput
-        toEnum (34) = SCHEME_QcqpSolverOutput
-        toEnum (35) = SCHEME_QpSolverInput
-        toEnum (36) = SCHEME_QpSolverOutput
-        toEnum (11) = SCHEME_RDAEInput
-        toEnum (12) = SCHEME_RDAEOutput
-        toEnum (37) = SCHEME_SDPInput
-        toEnum (38) = SCHEME_SDPOutput
-        toEnum (39) = SCHEME_SDQPInput
-        toEnum (40) = SCHEME_SDQPOutput
-        toEnum (41) = SCHEME_SOCPInput
-        toEnum (42) = SCHEME_SOCPOutput
-        toEnum (43) = SCHEME_SOCPStruct
-        toEnum (44) = SCHEME_StabilizedQpSolverInput
-        toEnum k
-          = error $ "InputOutputScheme: toEnum: got unhandled number: " ++
-              show k
-instance Marshal InputOutputScheme CInt where
-        marshal = return . fromIntegral . fromEnum
-instance WrapReturn CInt InputOutputScheme where
-        wrapReturn = return . toEnum . fromIntegral
-
 -- EnumDecl: Operation
-data Operation = NUM_BUILT_IN_OPS
-               | OP_ACOS
+data Operation = OP_ACOS
                | OP_ACOSH
                | OP_ADD
                | OP_ADDNONZEROS
@@ -285,6 +137,7 @@
                | OP_ATAN
                | OP_ATAN2
                | OP_ATANH
+               | OP_BILIN
                | OP_CALL
                | OP_CEIL
                | OP_CONST
@@ -296,6 +149,7 @@
                | OP_DIAGCAT
                | OP_DIAGSPLIT
                | OP_DIV
+               | OP_DOT
                | OP_EQ
                | OP_ERF
                | OP_ERFINV
@@ -312,7 +166,6 @@
                | OP_HORZREPSUM
                | OP_HORZSPLIT
                | OP_IF_ELSE_ZERO
-               | OP_INNER_PROD
                | OP_INPUT
                | OP_INV
                | OP_INVERSE
@@ -321,8 +174,8 @@
                | OP_LOG
                | OP_LT
                | OP_MAP
-               | OP_MATMUL
                | OP_MONITOR
+               | OP_MTIMES
                | OP_MUL
                | OP_NE
                | OP_NEG
@@ -337,6 +190,7 @@
                | OP_POW
                | OP_PRINTME
                | OP_PROJECT
+               | OP_RANK1
                | OP_RESHAPE
                | OP_SETNONZEROS
                | OP_SIGN
@@ -356,19 +210,19 @@
                | OP_VERTSPLIT
                deriving (Show, Eq)
 instance Enum Operation where
-        fromEnum (NUM_BUILT_IN_OPS) = 81
         fromEnum (OP_ACOS) = 17
         fromEnum (OP_ACOSH) = 41
         fromEnum (OP_ADD) = 1
-        fromEnum (OP_ADDNONZEROS) = 67
+        fromEnum (OP_ADDNONZEROS) = 69
         fromEnum (OP_AND) = 24
         fromEnum (OP_ASIN) = 16
         fromEnum (OP_ASINH) = 40
-        fromEnum (OP_ASSERTION) = 70
+        fromEnum (OP_ASSERTION) = 72
         fromEnum (OP_ASSIGN) = 0
         fromEnum (OP_ATAN) = 18
         fromEnum (OP_ATAN2) = 43
         fromEnum (OP_ATANH) = 42
+        fromEnum (OP_BILIN) = 57
         fromEnum (OP_CALL) = 48
         fromEnum (OP_CEIL) = 27
         fromEnum (OP_CONST) = 44
@@ -377,12 +231,13 @@
         fromEnum (OP_COS) = 14
         fromEnum (OP_COSH) = 38
         fromEnum (OP_DETERMINANT) = 54
-        fromEnum (OP_DIAGCAT) = 59
-        fromEnum (OP_DIAGSPLIT) = 62
+        fromEnum (OP_DIAGCAT) = 61
+        fromEnum (OP_DIAGSPLIT) = 64
         fromEnum (OP_DIV) = 4
+        fromEnum (OP_DOT) = 56
         fromEnum (OP_EQ) = 21
         fromEnum (OP_ERF) = 33
-        fromEnum (OP_ERFINV) = 78
+        fromEnum (OP_ERFINV) = 80
         fromEnum (OP_EXP) = 6
         fromEnum (OP_FABS) = 29
         fromEnum (OP_FIND) = 49
@@ -390,39 +245,39 @@
         fromEnum (OP_FMAX) = 35
         fromEnum (OP_FMIN) = 34
         fromEnum (OP_FMOD) = 28
-        fromEnum (OP_GETNONZEROS) = 66
-        fromEnum (OP_HORZCAT) = 57
-        fromEnum (OP_HORZREPMAT) = 76
-        fromEnum (OP_HORZREPSUM) = 77
-        fromEnum (OP_HORZSPLIT) = 60
+        fromEnum (OP_GETNONZEROS) = 68
+        fromEnum (OP_HORZCAT) = 59
+        fromEnum (OP_HORZREPMAT) = 78
+        fromEnum (OP_HORZREPSUM) = 79
+        fromEnum (OP_HORZSPLIT) = 62
         fromEnum (OP_IF_ELSE_ZERO) = 32
-        fromEnum (OP_INNER_PROD) = 56
         fromEnum (OP_INPUT) = 45
         fromEnum (OP_INV) = 36
         fromEnum (OP_INVERSE) = 55
         fromEnum (OP_LE) = 20
-        fromEnum (OP_LIFT) = 80
+        fromEnum (OP_LIFT) = 82
         fromEnum (OP_LOG) = 7
         fromEnum (OP_LT) = 19
         fromEnum (OP_MAP) = 50
-        fromEnum (OP_MATMUL) = 51
-        fromEnum (OP_MONITOR) = 71
+        fromEnum (OP_MONITOR) = 73
+        fromEnum (OP_MTIMES) = 51
         fromEnum (OP_MUL) = 3
         fromEnum (OP_NE) = 22
         fromEnum (OP_NEG) = 5
-        fromEnum (OP_NORM1) = 73
-        fromEnum (OP_NORM2) = 72
-        fromEnum (OP_NORMF) = 75
-        fromEnum (OP_NORMINF) = 74
+        fromEnum (OP_NORM1) = 75
+        fromEnum (OP_NORM2) = 74
+        fromEnum (OP_NORMF) = 77
+        fromEnum (OP_NORMINF) = 76
         fromEnum (OP_NOT) = 23
         fromEnum (OP_OR) = 25
         fromEnum (OP_OUTPUT) = 46
         fromEnum (OP_PARAMETER) = 47
         fromEnum (OP_POW) = 8
-        fromEnum (OP_PRINTME) = 79
-        fromEnum (OP_PROJECT) = 69
-        fromEnum (OP_RESHAPE) = 63
-        fromEnum (OP_SETNONZEROS) = 68
+        fromEnum (OP_PRINTME) = 81
+        fromEnum (OP_PROJECT) = 71
+        fromEnum (OP_RANK1) = 58
+        fromEnum (OP_RESHAPE) = 65
+        fromEnum (OP_SETNONZEROS) = 70
         fromEnum (OP_SIGN) = 30
         fromEnum (OP_SIN) = 13
         fromEnum (OP_SINH) = 37
@@ -430,27 +285,27 @@
         fromEnum (OP_SQ) = 11
         fromEnum (OP_SQRT) = 10
         fromEnum (OP_SUB) = 2
-        fromEnum (OP_SUBASSIGN) = 65
-        fromEnum (OP_SUBREF) = 64
+        fromEnum (OP_SUBASSIGN) = 67
+        fromEnum (OP_SUBREF) = 66
         fromEnum (OP_TAN) = 15
         fromEnum (OP_TANH) = 39
         fromEnum (OP_TRANSPOSE) = 53
         fromEnum (OP_TWICE) = 12
-        fromEnum (OP_VERTCAT) = 58
-        fromEnum (OP_VERTSPLIT) = 61
-        toEnum (81) = NUM_BUILT_IN_OPS
+        fromEnum (OP_VERTCAT) = 60
+        fromEnum (OP_VERTSPLIT) = 63
         toEnum (17) = OP_ACOS
         toEnum (41) = OP_ACOSH
         toEnum (1) = OP_ADD
-        toEnum (67) = OP_ADDNONZEROS
+        toEnum (69) = OP_ADDNONZEROS
         toEnum (24) = OP_AND
         toEnum (16) = OP_ASIN
         toEnum (40) = OP_ASINH
-        toEnum (70) = OP_ASSERTION
+        toEnum (72) = OP_ASSERTION
         toEnum (0) = OP_ASSIGN
         toEnum (18) = OP_ATAN
         toEnum (43) = OP_ATAN2
         toEnum (42) = OP_ATANH
+        toEnum (57) = OP_BILIN
         toEnum (48) = OP_CALL
         toEnum (27) = OP_CEIL
         toEnum (44) = OP_CONST
@@ -459,12 +314,13 @@
         toEnum (14) = OP_COS
         toEnum (38) = OP_COSH
         toEnum (54) = OP_DETERMINANT
-        toEnum (59) = OP_DIAGCAT
-        toEnum (62) = OP_DIAGSPLIT
+        toEnum (61) = OP_DIAGCAT
+        toEnum (64) = OP_DIAGSPLIT
         toEnum (4) = OP_DIV
+        toEnum (56) = OP_DOT
         toEnum (21) = OP_EQ
         toEnum (33) = OP_ERF
-        toEnum (78) = OP_ERFINV
+        toEnum (80) = OP_ERFINV
         toEnum (6) = OP_EXP
         toEnum (29) = OP_FABS
         toEnum (49) = OP_FIND
@@ -472,39 +328,39 @@
         toEnum (35) = OP_FMAX
         toEnum (34) = OP_FMIN
         toEnum (28) = OP_FMOD
-        toEnum (66) = OP_GETNONZEROS
-        toEnum (57) = OP_HORZCAT
-        toEnum (76) = OP_HORZREPMAT
-        toEnum (77) = OP_HORZREPSUM
-        toEnum (60) = OP_HORZSPLIT
+        toEnum (68) = OP_GETNONZEROS
+        toEnum (59) = OP_HORZCAT
+        toEnum (78) = OP_HORZREPMAT
+        toEnum (79) = OP_HORZREPSUM
+        toEnum (62) = OP_HORZSPLIT
         toEnum (32) = OP_IF_ELSE_ZERO
-        toEnum (56) = OP_INNER_PROD
         toEnum (45) = OP_INPUT
         toEnum (36) = OP_INV
         toEnum (55) = OP_INVERSE
         toEnum (20) = OP_LE
-        toEnum (80) = OP_LIFT
+        toEnum (82) = OP_LIFT
         toEnum (7) = OP_LOG
         toEnum (19) = OP_LT
         toEnum (50) = OP_MAP
-        toEnum (51) = OP_MATMUL
-        toEnum (71) = OP_MONITOR
+        toEnum (73) = OP_MONITOR
+        toEnum (51) = OP_MTIMES
         toEnum (3) = OP_MUL
         toEnum (22) = OP_NE
         toEnum (5) = OP_NEG
-        toEnum (73) = OP_NORM1
-        toEnum (72) = OP_NORM2
-        toEnum (75) = OP_NORMF
-        toEnum (74) = OP_NORMINF
+        toEnum (75) = OP_NORM1
+        toEnum (74) = OP_NORM2
+        toEnum (77) = OP_NORMF
+        toEnum (76) = OP_NORMINF
         toEnum (23) = OP_NOT
         toEnum (25) = OP_OR
         toEnum (46) = OP_OUTPUT
         toEnum (47) = OP_PARAMETER
         toEnum (8) = OP_POW
-        toEnum (79) = OP_PRINTME
-        toEnum (69) = OP_PROJECT
-        toEnum (63) = OP_RESHAPE
-        toEnum (68) = OP_SETNONZEROS
+        toEnum (81) = OP_PRINTME
+        toEnum (71) = OP_PROJECT
+        toEnum (58) = OP_RANK1
+        toEnum (65) = OP_RESHAPE
+        toEnum (70) = OP_SETNONZEROS
         toEnum (30) = OP_SIGN
         toEnum (13) = OP_SIN
         toEnum (37) = OP_SINH
@@ -512,14 +368,14 @@
         toEnum (11) = OP_SQ
         toEnum (10) = OP_SQRT
         toEnum (2) = OP_SUB
-        toEnum (65) = OP_SUBASSIGN
-        toEnum (64) = OP_SUBREF
+        toEnum (67) = OP_SUBASSIGN
+        toEnum (66) = OP_SUBREF
         toEnum (15) = OP_TAN
         toEnum (39) = OP_TANH
         toEnum (53) = OP_TRANSPOSE
         toEnum (12) = OP_TWICE
-        toEnum (58) = OP_VERTCAT
-        toEnum (61) = OP_VERTSPLIT
+        toEnum (60) = OP_VERTCAT
+        toEnum (63) = OP_VERTSPLIT
         toEnum k
           = error $ "Operation: toEnum: got unhandled number: " ++ show k
 instance Marshal Operation CInt where
@@ -528,56 +384,50 @@
         wrapReturn = return . toEnum . fromIntegral
 
 -- EnumDecl: TypeID
-data TypeID = OT_BOOLEAN
+data TypeID = OT_BOOL
             | OT_BOOLVECTOR
-            | OT_CALLBACK
-            | OT_DERIVATIVEGENERATOR
             | OT_DICT
+            | OT_DOUBLE
+            | OT_DOUBLEVECTOR
             | OT_FUNCTION
-            | OT_INTEGER
-            | OT_INTEGERVECTOR
-            | OT_INTEGERVECTORVECTOR
+            | OT_INT
+            | OT_INTVECTOR
+            | OT_INTVECTORVECTOR
             | OT_NULL
-            | OT_REAL
-            | OT_REALVECTOR
             | OT_STRING
             | OT_STRINGVECTOR
             | OT_UNKNOWN
             | OT_VOIDPTR
             deriving (Show, Eq)
 instance Enum TypeID where
-        fromEnum (OT_BOOLEAN) = 1
+        fromEnum (OT_BOOL) = 1
         fromEnum (OT_BOOLVECTOR) = 7
-        fromEnum (OT_CALLBACK) = 13
-        fromEnum (OT_DERIVATIVEGENERATOR) = 11
         fromEnum (OT_DICT) = 10
-        fromEnum (OT_FUNCTION) = 12
-        fromEnum (OT_INTEGER) = 2
-        fromEnum (OT_INTEGERVECTOR) = 5
-        fromEnum (OT_INTEGERVECTORVECTOR) = 6
+        fromEnum (OT_DOUBLE) = 3
+        fromEnum (OT_DOUBLEVECTOR) = 8
+        fromEnum (OT_FUNCTION) = 11
+        fromEnum (OT_INT) = 2
+        fromEnum (OT_INTVECTOR) = 5
+        fromEnum (OT_INTVECTORVECTOR) = 6
         fromEnum (OT_NULL) = 0
-        fromEnum (OT_REAL) = 3
-        fromEnum (OT_REALVECTOR) = 8
         fromEnum (OT_STRING) = 4
         fromEnum (OT_STRINGVECTOR) = 9
-        fromEnum (OT_UNKNOWN) = 15
-        fromEnum (OT_VOIDPTR) = 14
-        toEnum (1) = OT_BOOLEAN
+        fromEnum (OT_UNKNOWN) = 13
+        fromEnum (OT_VOIDPTR) = 12
+        toEnum (1) = OT_BOOL
         toEnum (7) = OT_BOOLVECTOR
-        toEnum (13) = OT_CALLBACK
-        toEnum (11) = OT_DERIVATIVEGENERATOR
         toEnum (10) = OT_DICT
-        toEnum (12) = OT_FUNCTION
-        toEnum (2) = OT_INTEGER
-        toEnum (5) = OT_INTEGERVECTOR
-        toEnum (6) = OT_INTEGERVECTORVECTOR
+        toEnum (3) = OT_DOUBLE
+        toEnum (8) = OT_DOUBLEVECTOR
+        toEnum (11) = OT_FUNCTION
+        toEnum (2) = OT_INT
+        toEnum (5) = OT_INTVECTOR
+        toEnum (6) = OT_INTVECTORVECTOR
         toEnum (0) = OT_NULL
-        toEnum (3) = OT_REAL
-        toEnum (8) = OT_REALVECTOR
         toEnum (4) = OT_STRING
         toEnum (9) = OT_STRINGVECTOR
-        toEnum (15) = OT_UNKNOWN
-        toEnum (14) = OT_VOIDPTR
+        toEnum (13) = OT_UNKNOWN
+        toEnum (12) = OT_VOIDPTR
         toEnum k
           = error $ "TypeID: toEnum: got unhandled number: " ++ show k
 instance Marshal TypeID CInt where
diff --git a/Casadi/Core/Tools.hs b/Casadi/Core/Tools.hs
--- a/Casadi/Core/Tools.hs
+++ b/Casadi/Core/Tools.hs
@@ -6,43779 +6,20995 @@
          casadi_abs__1,
          casadi_abs__2,
          casadi_abs__3,
-         casadi_acos__0,
-         casadi_acos__1,
-         casadi_acos__2,
-         casadi_acos__3,
-         casadi_acosh__0,
-         casadi_acosh__1,
-         casadi_acosh__2,
-         casadi_acosh__3,
-         casadi_adj__0,
-         casadi_adj__1,
-         casadi_adj__2,
-         casadi_all__0,
-         casadi_all__1,
-         casadi_all__2,
-         casadi_and__0,
-         casadi_and__1,
-         casadi_and__2,
-         casadi_and__3,
-         casadi_any__0,
-         casadi_any__1,
-         casadi_any__2,
-         casadi_asin__0,
-         casadi_asin__1,
-         casadi_asin__2,
-         casadi_asin__3,
-         casadi_asinh__0,
-         casadi_asinh__1,
-         casadi_asinh__2,
-         casadi_asinh__3,
-         casadi_atan2__0,
-         casadi_atan2__1,
-         casadi_atan2__2,
-         casadi_atan2__3,
-         casadi_atan__0,
-         casadi_atan__1,
-         casadi_atan__2,
-         casadi_atan__3,
-         casadi_atanh__0,
-         casadi_atanh__1,
-         casadi_atanh__2,
-         casadi_atanh__3,
-         casadi_blockcat__0,
-         casadi_blockcat__1,
-         casadi_blockcat__2,
-         casadi_blockcat__3,
-         casadi_blockcat__4,
-         casadi_blockcat__5,
-         casadi_blockcat__6,
-         casadi_blockcat__7,
-         casadi_blockcat__8,
-         casadi_blockcat__9,
-         casadi_blocksplit__0,
-         casadi_blocksplit__1,
-         casadi_blocksplit__10,
-         casadi_blocksplit__11,
-         casadi_blocksplit__12,
-         casadi_blocksplit__13,
-         casadi_blocksplit__14,
-         casadi_blocksplit__15,
-         casadi_blocksplit__16,
-         casadi_blocksplit__17,
-         casadi_blocksplit__18,
-         casadi_blocksplit__19,
-         casadi_blocksplit__2,
-         casadi_blocksplit__3,
-         casadi_blocksplit__4,
-         casadi_blocksplit__5,
-         casadi_blocksplit__6,
-         casadi_blocksplit__7,
-         casadi_blocksplit__8,
-         casadi_blocksplit__9,
-         casadi_ceil__0,
-         casadi_ceil__1,
-         casadi_ceil__2,
-         casadi_ceil__3,
-         casadi_chol__0,
-         casadi_chol__1,
-         casadi_chol__2,
-         casadi_cofactor__0,
-         casadi_cofactor__1,
-         casadi_cofactor__2,
-         casadi_conditional__0,
-         casadi_conditional__1,
-         casadi_conditional__2,
-         casadi_conditional__3,
-         casadi_conditional__4,
-         casadi_conditional__5,
-         casadi_conditional__6,
-         casadi_conditional__7,
-         casadi_constpow__0,
-         casadi_constpow__1,
-         casadi_constpow__2,
-         casadi_constpow__3,
-         casadi_copysign__0,
-         casadi_copysign__1,
-         casadi_copysign__2,
-         casadi_copysign__3,
-         casadi_cos__0,
-         casadi_cos__1,
-         casadi_cos__2,
-         casadi_cos__3,
-         casadi_cosh__0,
-         casadi_cosh__1,
-         casadi_cosh__2,
-         casadi_cosh__3,
-         casadi_countNodes__0,
-         casadi_countNodes__1,
-         casadi_countNodes__2,
-         casadi_countNodes__3,
-         casadi_cross__0,
-         casadi_cross__1,
-         casadi_cross__2,
-         casadi_cross__3,
-         casadi_cross__4,
-         casadi_cross__5,
-         casadi_cross__6,
-         casadi_cross__7,
-         casadi_densify__0,
-         casadi_densify__1,
-         casadi_densify__2,
-         casadi_densify__3,
-         casadi_dependsOn__0,
-         casadi_dependsOn__1,
-         casadi_dependsOn__2,
-         casadi_dependsOn__3,
-         casadi_det__0,
-         casadi_det__1,
-         casadi_det__2,
-         casadi_det__3,
-         casadi_diag__0,
-         casadi_diag__1,
-         casadi_diag__2,
-         casadi_diag__3,
-         casadi_diagcat__0,
-         casadi_diagcat__1,
-         casadi_diagcat__2,
-         casadi_diagcat__3,
-         casadi_diagcat__4,
-         casadi_diagsplit__0,
-         casadi_diagsplit__1,
-         casadi_diagsplit__10,
-         casadi_diagsplit__11,
-         casadi_diagsplit__12,
-         casadi_diagsplit__13,
-         casadi_diagsplit__14,
-         casadi_diagsplit__15,
-         casadi_diagsplit__16,
-         casadi_diagsplit__17,
-         casadi_diagsplit__18,
-         casadi_diagsplit__19,
-         casadi_diagsplit__2,
-         casadi_diagsplit__20,
-         casadi_diagsplit__21,
-         casadi_diagsplit__22,
-         casadi_diagsplit__23,
-         casadi_diagsplit__24,
-         casadi_diagsplit__3,
-         casadi_diagsplit__4,
-         casadi_diagsplit__5,
-         casadi_diagsplit__6,
-         casadi_diagsplit__7,
-         casadi_diagsplit__8,
-         casadi_diagsplit__9,
-         casadi_eig_symbolic__0,
-         casadi_eig_symbolic__1,
-         casadi_eig_symbolic__2,
-         casadi_eq__0,
-         casadi_eq__1,
-         casadi_eq__2,
-         casadi_eq__3,
-         casadi_erf__0,
-         casadi_erf__1,
-         casadi_erf__2,
-         casadi_erf__3,
-         casadi_erfinv__0,
-         casadi_erfinv__1,
-         casadi_erfinv__2,
-         casadi_erfinv__3,
-         casadi_exp__0,
-         casadi_exp__1,
-         casadi_exp__2,
-         casadi_exp__3,
-         casadi_expand__0,
-         casadi_expand__1,
-         casadi_expand__2,
-         casadi_extractShared__0,
-         casadi_extractShared__1,
-         casadi_extractShared__10,
-         casadi_extractShared__11,
-         casadi_extractShared__2,
-         casadi_extractShared__3,
-         casadi_extractShared__4,
-         casadi_extractShared__5,
-         casadi_extractShared__6,
-         casadi_extractShared__7,
-         casadi_extractShared__8,
-         casadi_extractShared__9,
-         casadi_find,
-         casadi_floor__0,
-         casadi_floor__1,
-         casadi_floor__2,
-         casadi_floor__3,
-         casadi_gauss_quadrature__0,
-         casadi_gauss_quadrature__1,
-         casadi_gauss_quadrature__2,
-         casadi_gauss_quadrature__3,
-         casadi_gauss_quadrature__4,
-         casadi_gauss_quadrature__5,
-         casadi_gauss_quadrature__6,
-         casadi_gauss_quadrature__7,
-         casadi_gauss_quadrature__8,
-         casadi_ge__0,
-         casadi_ge__1,
-         casadi_ge__2,
-         casadi_ge__3,
-         casadi_getMinor__0,
-         casadi_getMinor__1,
-         casadi_getMinor__2,
-         casadi_getOperatorRepresentation__0,
-         casadi_getOperatorRepresentation__1,
-         casadi_getOperatorRepresentation__2,
-         casadi_getOperatorRepresentation__3,
-         casadi_gradient__0,
-         casadi_gradient__1,
-         casadi_gradient__2,
-         casadi_gradient__3,
-         casadi_graph_substitute__0,
-         casadi_graph_substitute__1,
-         casadi_gt__0,
-         casadi_gt__1,
-         casadi_gt__2,
-         casadi_gt__3,
-         casadi_heaviside__0,
-         casadi_heaviside__1,
-         casadi_heaviside__2,
-         casadi_hessian__0,
-         casadi_hessian__1,
-         casadi_hessian__2,
-         casadi_hessian__3,
-         casadi_horzcat__0,
-         casadi_horzcat__1,
-         casadi_horzcat__2,
-         casadi_horzcat__3,
-         casadi_horzcat__4,
-         casadi_horzsplit__0,
-         casadi_horzsplit__1,
-         casadi_horzsplit__10,
-         casadi_horzsplit__11,
-         casadi_horzsplit__12,
-         casadi_horzsplit__13,
-         casadi_horzsplit__14,
-         casadi_horzsplit__2,
-         casadi_horzsplit__3,
-         casadi_horzsplit__4,
-         casadi_horzsplit__5,
-         casadi_horzsplit__6,
-         casadi_horzsplit__7,
-         casadi_horzsplit__8,
-         casadi_horzsplit__9,
-         casadi_if_else__0,
-         casadi_if_else__1,
-         casadi_if_else__2,
-         casadi_if_else__3,
-         casadi_if_else__4,
-         casadi_if_else__5,
-         casadi_if_else__6,
-         casadi_if_else__7,
-         casadi_inner_prod__0,
-         casadi_inner_prod__1,
-         casadi_inner_prod__2,
-         casadi_inner_prod__3,
-         casadi_inv__0,
-         casadi_inv__1,
-         casadi_inv__2,
-         casadi_inv__3,
-         casadi_isEqual__0,
-         casadi_isEqual__1,
-         casadi_isEqual__2,
-         casadi_isEqual__3,
-         casadi_isEqual__4,
-         casadi_isEqual__5,
-         casadi_isEqual__6,
-         casadi_isEqual__7,
-         casadi_iszero__0,
-         casadi_iszero__1,
-         casadi_iszero__2,
-         casadi_iszero__3,
-         casadi_jacobianTimesVector__0,
-         casadi_jacobianTimesVector__1,
-         casadi_jacobianTimesVector__2,
-         casadi_jacobianTimesVector__3,
-         casadi_jacobianTimesVector__4,
-         casadi_jacobianTimesVector__5,
-         casadi_jacobian__0,
-         casadi_jacobian__1,
-         casadi_jacobian__2,
-         casadi_jacobian__3,
-         casadi_kron__0,
-         casadi_kron__1,
-         casadi_kron__2,
-         casadi_kron__3,
-         casadi_kron__4,
-         casadi_ldivide__0,
-         casadi_ldivide__1,
-         casadi_ldivide__2,
-         casadi_ldivide__3,
-         casadi_le__0,
-         casadi_le__1,
-         casadi_le__2,
-         casadi_le__3,
-         casadi_linspace__0,
-         casadi_linspace__1,
-         casadi_linspace__2,
-         casadi_linspace__3,
-         casadi_log10__0,
-         casadi_log10__1,
-         casadi_log10__2,
-         casadi_log10__3,
-         casadi_log__0,
-         casadi_log__1,
-         casadi_log__2,
-         casadi_log__3,
-         casadi_lt__0,
-         casadi_lt__1,
-         casadi_lt__2,
-         casadi_lt__3,
-         casadi_mac__0,
-         casadi_mac__1,
-         casadi_mac__2,
-         casadi_mac__3,
-         casadi_mac__4,
-         casadi_matrix_expand__0,
-         casadi_matrix_expand__1,
-         casadi_matrix_expand__2,
-         casadi_matrix_expand__3,
-         casadi_matrix_expand__4,
-         casadi_matrix_expand__5,
-         casadi_max__0,
-         casadi_max__1,
-         casadi_max__2,
-         casadi_max__3,
-         casadi_min__0,
-         casadi_min__1,
-         casadi_min__2,
-         casadi_min__3,
-         casadi_minus__0,
-         casadi_minus__1,
-         casadi_minus__2,
-         casadi_minus__3,
-         casadi_mldivide__0,
-         casadi_mldivide__1,
-         casadi_mldivide__2,
-         casadi_mldivide__3,
-         casadi_mod__0,
-         casadi_mod__1,
-         casadi_mod__2,
-         casadi_mod__3,
-         casadi_mpower__0,
-         casadi_mpower__1,
-         casadi_mpower__2,
-         casadi_mpower__3,
-         casadi_mrdivide__0,
-         casadi_mrdivide__1,
-         casadi_mrdivide__2,
-         casadi_mrdivide__3,
-         casadi_mtaylor__0,
-         casadi_mtaylor__1,
-         casadi_mtaylor__2,
-         casadi_mtaylor__3,
-         casadi_mtaylor__4,
-         casadi_mtaylor__5,
-         casadi_mtaylor__6,
-         casadi_mtaylor__7,
-         casadi_mtaylor__8,
-         casadi_mul__0,
-         casadi_mul__1,
-         casadi_mul__2,
-         casadi_mul__3,
-         casadi_mul__4,
-         casadi_mul__5,
-         casadi_mul__6,
-         casadi_mul__7,
-         casadi_mul__8,
-         casadi_mul__9,
-         casadi_ne__0,
-         casadi_ne__1,
-         casadi_ne__2,
-         casadi_ne__3,
-         casadi_norm_0_mul__0,
-         casadi_norm_0_mul__1,
-         casadi_norm_0_mul__2,
-         casadi_norm_0_mul__3,
-         casadi_norm_0_mul__4,
-         casadi_norm_1__0,
-         casadi_norm_1__1,
-         casadi_norm_1__2,
-         casadi_norm_1__3,
-         casadi_norm_2__0,
-         casadi_norm_2__1,
-         casadi_norm_2__2,
-         casadi_norm_2__3,
-         casadi_norm_F__0,
-         casadi_norm_F__1,
-         casadi_norm_F__2,
-         casadi_norm_F__3,
-         casadi_norm_inf__0,
-         casadi_norm_inf__1,
-         casadi_norm_inf__2,
-         casadi_norm_inf__3,
-         casadi_norm_inf_mul__0,
-         casadi_norm_inf_mul__1,
-         casadi_norm_inf_mul__2,
-         casadi_not__0,
-         casadi_not__1,
-         casadi_not__2,
-         casadi_not__3,
-         casadi_nullspace__0,
-         casadi_nullspace__1,
-         casadi_nullspace__2,
-         casadi_nullspace__3,
-         casadi_offset__0,
-         casadi_offset__1,
-         casadi_offset__2,
-         casadi_offset__3,
-         casadi_offset__4,
-         casadi_offset__5,
-         casadi_offset__6,
-         casadi_offset__7,
-         casadi_offset__8,
-         casadi_offset__9,
-         casadi_or__0,
-         casadi_or__1,
-         casadi_or__2,
-         casadi_or__3,
-         casadi_outer_prod__0,
-         casadi_outer_prod__1,
-         casadi_outer_prod__2,
-         casadi_outer_prod__3,
-         casadi_pinv__0,
-         casadi_pinv__1,
-         casadi_pinv__10,
-         casadi_pinv__11,
-         casadi_pinv__2,
-         casadi_pinv__3,
-         casadi_pinv__4,
-         casadi_pinv__5,
-         casadi_pinv__6,
-         casadi_pinv__7,
-         casadi_pinv__8,
-         casadi_pinv__9,
-         casadi_plus__0,
-         casadi_plus__1,
-         casadi_plus__2,
-         casadi_plus__3,
-         casadi_poly_coeff__0,
-         casadi_poly_coeff__1,
-         casadi_poly_coeff__2,
-         casadi_poly_roots__0,
-         casadi_poly_roots__1,
-         casadi_poly_roots__2,
-         casadi_polyval__0,
-         casadi_polyval__1,
-         casadi_polyval__2,
-         casadi_polyval__3,
-         casadi_power__0,
-         casadi_power__1,
-         casadi_power__2,
-         casadi_power__3,
-         casadi_project__0,
-         casadi_project__1,
-         casadi_project__2,
-         casadi_project__3,
-         casadi_project__4,
-         casadi_project__5,
-         casadi_project__6,
-         casadi_project__7,
-         casadi_pw_const__0,
-         casadi_pw_const__1,
-         casadi_pw_const__2,
-         casadi_pw_lin__0,
-         casadi_pw_lin__1,
-         casadi_pw_lin__2,
-         casadi_qr__0,
-         casadi_qr__1,
-         casadi_qr__2,
-         casadi_quad_form__0,
-         casadi_quad_form__1,
-         casadi_quad_form__2,
-         casadi_quad_form__3,
-         casadi_quad_form__4,
-         casadi_quad_form__5,
-         casadi_quad_form__6,
-         casadi_quad_form__7,
-         casadi_ramp__0,
-         casadi_ramp__1,
-         casadi_ramp__2,
-         casadi_rdivide__0,
-         casadi_rdivide__1,
-         casadi_rdivide__2,
-         casadi_rdivide__3,
-         casadi_rectangle__0,
-         casadi_rectangle__1,
-         casadi_rectangle__2,
-         casadi_repmat__0,
-         casadi_repmat__1,
-         casadi_repmat__10,
-         casadi_repmat__11,
-         casadi_repmat__12,
-         casadi_repmat__13,
-         casadi_repmat__14,
-         casadi_repmat__2,
-         casadi_repmat__3,
-         casadi_repmat__4,
-         casadi_repmat__5,
-         casadi_repmat__6,
-         casadi_repmat__7,
-         casadi_repmat__8,
-         casadi_repmat__9,
-         casadi_repsum__0,
-         casadi_repsum__1,
-         casadi_repsum__2,
-         casadi_repsum__3,
-         casadi_repsum__4,
-         casadi_repsum__5,
-         casadi_repsum__6,
-         casadi_repsum__7,
-         casadi_reshape__0,
-         casadi_reshape__1,
-         casadi_reshape__10,
-         casadi_reshape__11,
-         casadi_reshape__12,
-         casadi_reshape__13,
-         casadi_reshape__14,
-         casadi_reshape__2,
-         casadi_reshape__3,
-         casadi_reshape__4,
-         casadi_reshape__5,
-         casadi_reshape__6,
-         casadi_reshape__7,
-         casadi_reshape__8,
-         casadi_reshape__9,
-         casadi_sign__0,
-         casadi_sign__1,
-         casadi_sign__2,
-         casadi_sign__3,
-         casadi_simplify__0,
-         casadi_simplify__1,
-         casadi_simplify__2,
-         casadi_simplify__3,
-         casadi_sin__0,
-         casadi_sin__1,
-         casadi_sin__2,
-         casadi_sin__3,
-         casadi_sinh__0,
-         casadi_sinh__1,
-         casadi_sinh__2,
-         casadi_sinh__3,
-         casadi_solve__0,
-         casadi_solve__1,
-         casadi_solve__10,
-         casadi_solve__11,
-         casadi_solve__2,
-         casadi_solve__3,
-         casadi_solve__4,
-         casadi_solve__5,
-         casadi_solve__6,
-         casadi_solve__7,
-         casadi_solve__8,
-         casadi_solve__9,
-         casadi_sparsify__0,
-         casadi_sparsify__1,
-         casadi_sparsify__2,
-         casadi_sparsify__3,
-         casadi_sparsify__4,
-         casadi_sparsify__5,
-         casadi_sprank__0,
-         casadi_sprank__1,
-         casadi_sprank__2,
-         casadi_sprank__3,
-         casadi_sprank__4,
-         casadi_sqrt__0,
-         casadi_sqrt__1,
-         casadi_sqrt__2,
-         casadi_sqrt__3,
-         casadi_substituteInPlace__0,
-         casadi_substituteInPlace__1,
-         casadi_substituteInPlace__2,
-         casadi_substituteInPlace__3,
-         casadi_substituteInPlace__4,
-         casadi_substituteInPlace__5,
-         casadi_substituteInPlace__6,
-         casadi_substituteInPlace__7,
-         casadi_substitute__0,
-         casadi_substitute__1,
-         casadi_substitute__2,
-         casadi_substitute__3,
-         casadi_substitute__4,
-         casadi_substitute__5,
-         casadi_substitute__6,
-         casadi_substitute__7,
-         casadi_sumCols__0,
-         casadi_sumCols__1,
-         casadi_sumCols__2,
-         casadi_sumCols__3,
-         casadi_sumRows__0,
-         casadi_sumRows__1,
-         casadi_sumRows__2,
-         casadi_sumRows__3,
-         casadi_sum_square__0,
-         casadi_sum_square__1,
-         casadi_sum_square__2,
-         casadi_sum_square__3,
-         casadi_symvar__0,
-         casadi_symvar__1,
-         casadi_symvar__2,
-         casadi_symvar__3,
-         casadi_tan__0,
-         casadi_tan__1,
-         casadi_tan__2,
-         casadi_tan__3,
-         casadi_tangent__0,
-         casadi_tangent__1,
-         casadi_tangent__2,
-         casadi_tangent__3,
-         casadi_tanh__0,
-         casadi_tanh__1,
-         casadi_tanh__2,
-         casadi_tanh__3,
-         casadi_taylor__0,
-         casadi_taylor__1,
-         casadi_taylor__2,
-         casadi_taylor__3,
-         casadi_taylor__4,
-         casadi_taylor__5,
-         casadi_taylor__6,
-         casadi_taylor__7,
-         casadi_taylor__8,
-         casadi_times__0,
-         casadi_times__1,
-         casadi_times__2,
-         casadi_times__3,
-         casadi_trace__0,
-         casadi_trace__1,
-         casadi_trace__2,
-         casadi_trace__3,
-         casadi_transpose__0,
-         casadi_transpose__1,
-         casadi_transpose__2,
-         casadi_transpose__3,
-         casadi_transpose__4,
-         casadi_triangle__0,
-         casadi_triangle__1,
-         casadi_triangle__2,
-         casadi_tril2symm__0,
-         casadi_tril2symm__1,
-         casadi_tril2symm__2,
-         casadi_tril2symm__3,
-         casadi_tril__0,
-         casadi_tril__1,
-         casadi_tril__2,
-         casadi_tril__3,
-         casadi_tril__4,
-         casadi_tril__5,
-         casadi_tril__6,
-         casadi_tril__7,
-         casadi_tril__8,
-         casadi_tril__9,
-         casadi_triu2symm__0,
-         casadi_triu2symm__1,
-         casadi_triu2symm__2,
-         casadi_triu2symm__3,
-         casadi_triu__0,
-         casadi_triu__1,
-         casadi_triu__2,
-         casadi_triu__3,
-         casadi_triu__4,
-         casadi_triu__5,
-         casadi_triu__6,
-         casadi_triu__7,
-         casadi_triu__8,
-         casadi_triu__9,
-         casadi_unite__0,
-         casadi_unite__1,
-         casadi_unite__2,
-         casadi_unite__3,
-         casadi_vecNZ__0,
-         casadi_vecNZ__1,
-         casadi_vecNZ__2,
-         casadi_vecNZ__3,
-         casadi_vecNZ__4,
-         casadi_vec__0,
-         casadi_vec__1,
-         casadi_vec__2,
-         casadi_vec__3,
-         casadi_vec__4,
-         casadi_veccat__0,
-         casadi_veccat__1,
-         casadi_veccat__2,
-         casadi_veccat__3,
-         casadi_veccat__4,
-         casadi_vertcat__0,
-         casadi_vertcat__1,
-         casadi_vertcat__2,
-         casadi_vertcat__3,
-         casadi_vertcat__4,
-         casadi_vertsplit__0,
-         casadi_vertsplit__1,
-         casadi_vertsplit__10,
-         casadi_vertsplit__11,
-         casadi_vertsplit__12,
-         casadi_vertsplit__13,
-         casadi_vertsplit__14,
-         casadi_vertsplit__2,
-         casadi_vertsplit__3,
-         casadi_vertsplit__4,
-         casadi_vertsplit__5,
-         casadi_vertsplit__6,
-         casadi_vertsplit__7,
-         casadi_vertsplit__8,
-         casadi_vertsplit__9,
-         cleIn__0,
-         cleIn__1,
-         cleIn__11,
-         cleIn__12,
-         cleIn__13,
-         cleIn__2,
-         cleIn__3,
-         cleIn__4,
-         cleIn__5,
-         cleIn__6,
-         cleIn__7,
-         cleIn__8,
-         cleOut__0,
-         cleOut__1,
-         cleOut__2,
-         cleOut__5,
-         collocationInterpolators,
-         collocationPoints__0,
-         collocationPoints__1,
-         complement,
-         controldaeIn__0,
-         controldaeIn__1,
-         controldaeIn__10,
-         controldaeIn__11,
-         controldaeIn__12,
-         controldaeIn__13,
-         controldaeIn__14,
-         controldaeIn__15,
-         controldaeIn__16,
-         controldaeIn__17,
-         controldaeIn__18,
-         controldaeIn__19,
-         controldaeIn__2,
-         controldaeIn__20,
-         controldaeIn__21,
-         controldaeIn__22,
-         controldaeIn__23,
-         controldaeIn__24,
-         controldaeIn__25,
-         controldaeIn__26,
-         controldaeIn__27,
-         controldaeIn__28,
-         controldaeIn__29,
-         controldaeIn__3,
-         controldaeIn__30,
-         controldaeIn__31,
-         controldaeIn__32,
-         controldaeIn__33,
-         controldaeIn__34,
-         controldaeIn__35,
-         controldaeIn__36,
-         controldaeIn__37,
-         controldaeIn__38,
-         controldaeIn__39,
-         controldaeIn__4,
-         controldaeIn__40,
-         controldaeIn__41,
-         controldaeIn__42,
-         controldaeIn__43,
-         controldaeIn__44,
-         controldaeIn__45,
-         controldaeIn__46,
-         controldaeIn__47,
-         controldaeIn__48,
-         controldaeIn__49,
-         controldaeIn__5,
-         controldaeIn__50,
-         controldaeIn__53,
-         controldaeIn__54,
-         controldaeIn__55,
-         controldaeIn__56,
-         controldaeIn__57,
-         controldaeIn__58,
-         controldaeIn__59,
-         controldaeIn__6,
-         controldaeIn__60,
-         controldaeIn__61,
-         controldaeIn__62,
-         controldaeIn__63,
-         controldaeIn__64,
-         controldaeIn__65,
-         controldaeIn__66,
-         controldaeIn__67,
-         controldaeIn__68,
-         controldaeIn__69,
-         controldaeIn__7,
-         controldaeIn__8,
-         controldaeIn__9,
-         controlsimulatorIn__0,
-         controlsimulatorIn__1,
-         controlsimulatorIn__10,
-         controlsimulatorIn__11,
-         controlsimulatorIn__12,
-         controlsimulatorIn__13,
-         controlsimulatorIn__14,
-         controlsimulatorIn__17,
-         controlsimulatorIn__18,
-         controlsimulatorIn__19,
-         controlsimulatorIn__2,
-         controlsimulatorIn__20,
-         controlsimulatorIn__21,
-         controlsimulatorIn__3,
-         controlsimulatorIn__4,
-         controlsimulatorIn__5,
-         controlsimulatorIn__6,
-         controlsimulatorIn__7,
-         controlsimulatorIn__8,
-         controlsimulatorIn__9,
-         daeIn__0,
-         daeIn__1,
-         daeIn__10,
-         daeIn__11,
-         daeIn__12,
-         daeIn__13,
-         daeIn__14,
-         daeIn__15,
-         daeIn__16,
-         daeIn__17,
-         daeIn__18,
-         daeIn__19,
-         daeIn__2,
-         daeIn__20,
-         daeIn__23,
-         daeIn__24,
-         daeIn__25,
-         daeIn__26,
-         daeIn__27,
-         daeIn__28,
-         daeIn__29,
-         daeIn__3,
-         daeIn__4,
-         daeIn__5,
-         daeIn__6,
-         daeIn__7,
-         daeIn__8,
-         daeIn__9,
-         daeOut__0,
-         daeOut__1,
-         daeOut__10,
-         daeOut__11,
-         daeOut__12,
-         daeOut__13,
-         daeOut__14,
-         daeOut__17,
-         daeOut__18,
-         daeOut__19,
-         daeOut__2,
-         daeOut__20,
-         daeOut__21,
-         daeOut__3,
-         daeOut__4,
-         daeOut__5,
-         daeOut__6,
-         daeOut__7,
-         daeOut__8,
-         daeOut__9,
-         dleIn__0,
-         dleIn__1,
-         dleIn__11,
-         dleIn__12,
-         dleIn__13,
-         dleIn__2,
-         dleIn__3,
-         dleIn__4,
-         dleIn__5,
-         dleIn__6,
-         dleIn__7,
-         dleIn__8,
-         dleOut__0,
-         dleOut__1,
-         dleOut__2,
-         dleOut__5,
-         dpleIn__0,
-         dpleIn__1,
-         dpleIn__11,
-         dpleIn__12,
-         dpleIn__13,
-         dpleIn__2,
-         dpleIn__3,
-         dpleIn__4,
-         dpleIn__5,
-         dpleIn__6,
-         dpleIn__7,
-         dpleIn__8,
-         dpleOut__0,
-         dpleOut__1,
-         dpleOut__2,
-         dpleOut__5,
-         getSchemeEntryDoc,
-         getSchemeEntryEnum,
-         getSchemeEntryEnumName,
-         getSchemeEntryName,
-         getSchemeEntryNames,
-         getSchemeName,
-         getSchemeSize,
-         gradFIn__0,
-         gradFIn__1,
-         gradFIn__11,
-         gradFIn__12,
-         gradFIn__13,
-         gradFIn__2,
-         gradFIn__3,
-         gradFIn__4,
-         gradFIn__5,
-         gradFIn__6,
-         gradFIn__7,
-         gradFIn__8,
-         gradFOut__0,
-         gradFOut__1,
-         gradFOut__10,
-         gradFOut__11,
-         gradFOut__12,
-         gradFOut__13,
-         gradFOut__14,
-         gradFOut__17,
-         gradFOut__18,
-         gradFOut__19,
-         gradFOut__2,
-         gradFOut__20,
-         gradFOut__21,
-         gradFOut__3,
-         gradFOut__4,
-         gradFOut__5,
-         gradFOut__6,
-         gradFOut__7,
-         gradFOut__8,
-         gradFOut__9,
-         hessLagIn__0,
-         hessLagIn__1,
-         hessLagIn__10,
-         hessLagIn__11,
-         hessLagIn__12,
-         hessLagIn__13,
-         hessLagIn__14,
-         hessLagIn__15,
-         hessLagIn__16,
-         hessLagIn__17,
-         hessLagIn__18,
-         hessLagIn__19,
-         hessLagIn__2,
-         hessLagIn__20,
-         hessLagIn__23,
-         hessLagIn__24,
-         hessLagIn__25,
-         hessLagIn__26,
-         hessLagIn__27,
-         hessLagIn__28,
-         hessLagIn__29,
-         hessLagIn__3,
-         hessLagIn__4,
-         hessLagIn__5,
-         hessLagIn__6,
-         hessLagIn__7,
-         hessLagIn__8,
-         hessLagIn__9,
-         hessLagOut__0,
-         hessLagOut__1,
-         hessLagOut__10,
-         hessLagOut__11,
-         hessLagOut__12,
-         hessLagOut__13,
-         hessLagOut__14,
-         hessLagOut__15,
-         hessLagOut__16,
-         hessLagOut__17,
-         hessLagOut__18,
-         hessLagOut__19,
-         hessLagOut__2,
-         hessLagOut__20,
-         hessLagOut__21,
-         hessLagOut__22,
-         hessLagOut__23,
-         hessLagOut__24,
-         hessLagOut__25,
-         hessLagOut__26,
-         hessLagOut__29,
-         hessLagOut__3,
-         hessLagOut__30,
-         hessLagOut__31,
-         hessLagOut__32,
-         hessLagOut__33,
-         hessLagOut__34,
-         hessLagOut__35,
-         hessLagOut__36,
-         hessLagOut__37,
-         hessLagOut__4,
-         hessLagOut__5,
-         hessLagOut__6,
-         hessLagOut__7,
-         hessLagOut__8,
-         hessLagOut__9,
-         hnlpIn__0,
-         hnlpIn__1,
-         hnlpIn__10,
-         hnlpIn__11,
-         hnlpIn__12,
-         hnlpIn__13,
-         hnlpIn__14,
-         hnlpIn__17,
-         hnlpIn__18,
-         hnlpIn__19,
-         hnlpIn__2,
-         hnlpIn__20,
-         hnlpIn__21,
-         hnlpIn__3,
-         hnlpIn__4,
-         hnlpIn__5,
-         hnlpIn__6,
-         hnlpIn__7,
-         hnlpIn__8,
-         hnlpIn__9,
-         iOScheme__0,
-         iOScheme__1,
-         iOScheme__10,
-         iOScheme__11,
-         iOScheme__12,
-         iOScheme__13,
-         iOScheme__14,
-         iOScheme__15,
-         iOScheme__16,
-         iOScheme__17,
-         iOScheme__18,
-         iOScheme__19,
-         iOScheme__2,
-         iOScheme__20,
-         iOScheme__21,
-         iOScheme__22,
-         iOScheme__23,
-         iOScheme__3,
-         iOScheme__4,
-         iOScheme__5,
-         iOScheme__6,
-         iOScheme__7,
-         iOScheme__8,
-         iOScheme__9,
-         integratorIn__0,
-         integratorIn__1,
-         integratorIn__10,
-         integratorIn__11,
-         integratorIn__12,
-         integratorIn__13,
-         integratorIn__14,
-         integratorIn__15,
-         integratorIn__16,
-         integratorIn__17,
-         integratorIn__18,
-         integratorIn__19,
-         integratorIn__2,
-         integratorIn__20,
-         integratorIn__21,
-         integratorIn__22,
-         integratorIn__23,
-         integratorIn__24,
-         integratorIn__25,
-         integratorIn__26,
-         integratorIn__27,
-         integratorIn__28,
-         integratorIn__29,
-         integratorIn__3,
-         integratorIn__30,
-         integratorIn__31,
-         integratorIn__32,
-         integratorIn__35,
-         integratorIn__36,
-         integratorIn__37,
-         integratorIn__38,
-         integratorIn__39,
-         integratorIn__4,
-         integratorIn__40,
-         integratorIn__41,
-         integratorIn__42,
-         integratorIn__43,
-         integratorIn__44,
-         integratorIn__45,
-         integratorIn__5,
-         integratorIn__6,
-         integratorIn__7,
-         integratorIn__8,
-         integratorIn__9,
-         integratorOut__0,
-         integratorOut__1,
-         integratorOut__10,
-         integratorOut__11,
-         integratorOut__12,
-         integratorOut__13,
-         integratorOut__14,
-         integratorOut__15,
-         integratorOut__16,
-         integratorOut__17,
-         integratorOut__18,
-         integratorOut__19,
-         integratorOut__2,
-         integratorOut__20,
-         integratorOut__21,
-         integratorOut__22,
-         integratorOut__23,
-         integratorOut__24,
-         integratorOut__25,
-         integratorOut__26,
-         integratorOut__27,
-         integratorOut__28,
-         integratorOut__29,
-         integratorOut__3,
-         integratorOut__30,
-         integratorOut__31,
-         integratorOut__32,
-         integratorOut__35,
-         integratorOut__36,
-         integratorOut__37,
-         integratorOut__38,
-         integratorOut__39,
-         integratorOut__4,
-         integratorOut__40,
-         integratorOut__41,
-         integratorOut__42,
-         integratorOut__43,
-         integratorOut__44,
-         integratorOut__45,
-         integratorOut__5,
-         integratorOut__6,
-         integratorOut__7,
-         integratorOut__8,
-         integratorOut__9,
-         jacGIn__0,
-         jacGIn__1,
-         jacGIn__11,
-         jacGIn__12,
-         jacGIn__13,
-         jacGIn__2,
-         jacGIn__3,
-         jacGIn__4,
-         jacGIn__5,
-         jacGIn__6,
-         jacGIn__7,
-         jacGIn__8,
-         jacGOut__0,
-         jacGOut__1,
-         jacGOut__10,
-         jacGOut__11,
-         jacGOut__12,
-         jacGOut__13,
-         jacGOut__14,
-         jacGOut__17,
-         jacGOut__18,
-         jacGOut__19,
-         jacGOut__2,
-         jacGOut__20,
-         jacGOut__21,
-         jacGOut__3,
-         jacGOut__4,
-         jacGOut__5,
-         jacGOut__6,
-         jacGOut__7,
-         jacGOut__8,
-         jacGOut__9,
-         linsolIn__0,
-         linsolIn__1,
-         linsolIn__11,
-         linsolIn__12,
-         linsolIn__13,
-         linsolIn__2,
-         linsolIn__3,
-         linsolIn__4,
-         linsolIn__5,
-         linsolIn__6,
-         linsolIn__7,
-         linsolIn__8,
-         linsolOut__0,
-         linsolOut__1,
-         linsolOut__2,
-         linsolOut__5,
-         lookupvector,
-         lpIn__0,
-         lpIn__1,
-         lpIn__10,
-         lpIn__11,
-         lpIn__12,
-         lpIn__13,
-         lpIn__14,
-         lpIn__15,
-         lpIn__16,
-         lpIn__17,
-         lpIn__18,
-         lpIn__19,
-         lpIn__2,
-         lpIn__20,
-         lpIn__21,
-         lpIn__22,
-         lpIn__23,
-         lpIn__24,
-         lpIn__25,
-         lpIn__26,
-         lpIn__27,
-         lpIn__28,
-         lpIn__29,
-         lpIn__3,
-         lpIn__30,
-         lpIn__31,
-         lpIn__32,
-         lpIn__35,
-         lpIn__36,
-         lpIn__37,
-         lpIn__38,
-         lpIn__39,
-         lpIn__4,
-         lpIn__40,
-         lpIn__41,
-         lpIn__42,
-         lpIn__43,
-         lpIn__44,
-         lpIn__45,
-         lpIn__5,
-         lpIn__6,
-         lpIn__7,
-         lpIn__8,
-         lpIn__9,
-         lpOut__0,
-         lpOut__1,
-         lpOut__10,
-         lpOut__11,
-         lpOut__12,
-         lpOut__13,
-         lpOut__14,
-         lpOut__15,
-         lpOut__16,
-         lpOut__17,
-         lpOut__18,
-         lpOut__19,
-         lpOut__2,
-         lpOut__20,
-         lpOut__23,
-         lpOut__24,
-         lpOut__25,
-         lpOut__26,
-         lpOut__27,
-         lpOut__28,
-         lpOut__29,
-         lpOut__3,
-         lpOut__4,
-         lpOut__5,
-         lpOut__6,
-         lpOut__7,
-         lpOut__8,
-         lpOut__9,
-         lrdleIn__0,
-         lrdleIn__1,
-         lrdleIn__10,
-         lrdleIn__11,
-         lrdleIn__12,
-         lrdleIn__13,
-         lrdleIn__14,
-         lrdleIn__15,
-         lrdleIn__16,
-         lrdleIn__17,
-         lrdleIn__18,
-         lrdleIn__19,
-         lrdleIn__2,
-         lrdleIn__20,
-         lrdleIn__23,
-         lrdleIn__24,
-         lrdleIn__25,
-         lrdleIn__26,
-         lrdleIn__27,
-         lrdleIn__28,
-         lrdleIn__29,
-         lrdleIn__3,
-         lrdleIn__4,
-         lrdleIn__5,
-         lrdleIn__6,
-         lrdleIn__7,
-         lrdleIn__8,
-         lrdleIn__9,
-         lrdleOut__0,
-         lrdleOut__1,
-         lrdleOut__2,
-         lrdleOut__5,
-         lrdpleIn__0,
-         lrdpleIn__1,
-         lrdpleIn__10,
-         lrdpleIn__11,
-         lrdpleIn__12,
-         lrdpleIn__13,
-         lrdpleIn__14,
-         lrdpleIn__15,
-         lrdpleIn__16,
-         lrdpleIn__17,
-         lrdpleIn__18,
-         lrdpleIn__19,
-         lrdpleIn__2,
-         lrdpleIn__20,
-         lrdpleIn__23,
-         lrdpleIn__24,
-         lrdpleIn__25,
-         lrdpleIn__26,
-         lrdpleIn__27,
-         lrdpleIn__28,
-         lrdpleIn__29,
-         lrdpleIn__3,
-         lrdpleIn__4,
-         lrdpleIn__5,
-         lrdpleIn__6,
-         lrdpleIn__7,
-         lrdpleIn__8,
-         lrdpleIn__9,
-         lrdpleOut__0,
-         lrdpleOut__1,
-         lrdpleOut__2,
-         lrdpleOut__5,
-         nlpIn__0,
-         nlpIn__1,
-         nlpIn__11,
-         nlpIn__12,
-         nlpIn__13,
-         nlpIn__2,
-         nlpIn__3,
-         nlpIn__4,
-         nlpIn__5,
-         nlpIn__6,
-         nlpIn__7,
-         nlpIn__8,
-         nlpOut__0,
-         nlpOut__1,
-         nlpOut__11,
-         nlpOut__12,
-         nlpOut__13,
-         nlpOut__2,
-         nlpOut__3,
-         nlpOut__4,
-         nlpOut__5,
-         nlpOut__6,
-         nlpOut__7,
-         nlpOut__8,
-         nlpSolverIn__0,
-         nlpSolverIn__1,
-         nlpSolverIn__10,
-         nlpSolverIn__11,
-         nlpSolverIn__12,
-         nlpSolverIn__13,
-         nlpSolverIn__14,
-         nlpSolverIn__15,
-         nlpSolverIn__16,
-         nlpSolverIn__17,
-         nlpSolverIn__18,
-         nlpSolverIn__19,
-         nlpSolverIn__2,
-         nlpSolverIn__20,
-         nlpSolverIn__21,
-         nlpSolverIn__22,
-         nlpSolverIn__23,
-         nlpSolverIn__24,
-         nlpSolverIn__25,
-         nlpSolverIn__26,
-         nlpSolverIn__27,
-         nlpSolverIn__28,
-         nlpSolverIn__29,
-         nlpSolverIn__3,
-         nlpSolverIn__30,
-         nlpSolverIn__31,
-         nlpSolverIn__32,
-         nlpSolverIn__33,
-         nlpSolverIn__34,
-         nlpSolverIn__35,
-         nlpSolverIn__36,
-         nlpSolverIn__37,
-         nlpSolverIn__38,
-         nlpSolverIn__39,
-         nlpSolverIn__4,
-         nlpSolverIn__40,
-         nlpSolverIn__41,
-         nlpSolverIn__42,
-         nlpSolverIn__43,
-         nlpSolverIn__44,
-         nlpSolverIn__47,
-         nlpSolverIn__48,
-         nlpSolverIn__49,
-         nlpSolverIn__5,
-         nlpSolverIn__50,
-         nlpSolverIn__51,
-         nlpSolverIn__52,
-         nlpSolverIn__53,
-         nlpSolverIn__54,
-         nlpSolverIn__55,
-         nlpSolverIn__56,
-         nlpSolverIn__57,
-         nlpSolverIn__58,
-         nlpSolverIn__59,
-         nlpSolverIn__6,
-         nlpSolverIn__60,
-         nlpSolverIn__61,
-         nlpSolverIn__7,
-         nlpSolverIn__8,
-         nlpSolverIn__9,
-         nlpSolverOut__0,
-         nlpSolverOut__1,
-         nlpSolverOut__10,
-         nlpSolverOut__11,
-         nlpSolverOut__12,
-         nlpSolverOut__13,
-         nlpSolverOut__14,
-         nlpSolverOut__15,
-         nlpSolverOut__16,
-         nlpSolverOut__17,
-         nlpSolverOut__18,
-         nlpSolverOut__19,
-         nlpSolverOut__2,
-         nlpSolverOut__20,
-         nlpSolverOut__21,
-         nlpSolverOut__22,
-         nlpSolverOut__23,
-         nlpSolverOut__24,
-         nlpSolverOut__25,
-         nlpSolverOut__26,
-         nlpSolverOut__27,
-         nlpSolverOut__28,
-         nlpSolverOut__29,
-         nlpSolverOut__3,
-         nlpSolverOut__30,
-         nlpSolverOut__31,
-         nlpSolverOut__32,
-         nlpSolverOut__35,
-         nlpSolverOut__36,
-         nlpSolverOut__37,
-         nlpSolverOut__38,
-         nlpSolverOut__39,
-         nlpSolverOut__4,
-         nlpSolverOut__40,
-         nlpSolverOut__41,
-         nlpSolverOut__42,
-         nlpSolverOut__43,
-         nlpSolverOut__44,
-         nlpSolverOut__45,
-         nlpSolverOut__5,
-         nlpSolverOut__6,
-         nlpSolverOut__7,
-         nlpSolverOut__8,
-         nlpSolverOut__9,
-         qcqpIn__0,
-         qcqpIn__1,
-         qcqpIn__10,
-         qcqpIn__11,
-         qcqpIn__12,
-         qcqpIn__13,
-         qcqpIn__14,
-         qcqpIn__15,
-         qcqpIn__16,
-         qcqpIn__17,
-         qcqpIn__18,
-         qcqpIn__19,
-         qcqpIn__2,
-         qcqpIn__20,
-         qcqpIn__21,
-         qcqpIn__22,
-         qcqpIn__23,
-         qcqpIn__24,
-         qcqpIn__25,
-         qcqpIn__26,
-         qcqpIn__27,
-         qcqpIn__28,
-         qcqpIn__29,
-         qcqpIn__3,
-         qcqpIn__30,
-         qcqpIn__31,
-         qcqpIn__32,
-         qcqpIn__33,
-         qcqpIn__34,
-         qcqpIn__35,
-         qcqpIn__36,
-         qcqpIn__37,
-         qcqpIn__38,
-         qcqpIn__39,
-         qcqpIn__4,
-         qcqpIn__40,
-         qcqpIn__41,
-         qcqpIn__42,
-         qcqpIn__43,
-         qcqpIn__44,
-         qcqpIn__45,
-         qcqpIn__46,
-         qcqpIn__47,
-         qcqpIn__48,
-         qcqpIn__49,
-         qcqpIn__5,
-         qcqpIn__50,
-         qcqpIn__51,
-         qcqpIn__52,
-         qcqpIn__53,
-         qcqpIn__54,
-         qcqpIn__55,
-         qcqpIn__56,
-         qcqpIn__57,
-         qcqpIn__58,
-         qcqpIn__59,
-         qcqpIn__6,
-         qcqpIn__60,
-         qcqpIn__61,
-         qcqpIn__62,
-         qcqpIn__63,
-         qcqpIn__64,
-         qcqpIn__65,
-         qcqpIn__66,
-         qcqpIn__67,
-         qcqpIn__68,
-         qcqpIn__7,
-         qcqpIn__71,
-         qcqpIn__72,
-         qcqpIn__73,
-         qcqpIn__74,
-         qcqpIn__75,
-         qcqpIn__76,
-         qcqpIn__77,
-         qcqpIn__78,
-         qcqpIn__79,
-         qcqpIn__8,
-         qcqpIn__80,
-         qcqpIn__81,
-         qcqpIn__82,
-         qcqpIn__83,
-         qcqpIn__84,
-         qcqpIn__85,
-         qcqpIn__86,
-         qcqpIn__87,
-         qcqpIn__88,
-         qcqpIn__89,
-         qcqpIn__9,
-         qcqpIn__90,
-         qcqpIn__91,
-         qcqpIn__92,
-         qcqpIn__93,
-         qcqpOut__0,
-         qcqpOut__1,
-         qcqpOut__10,
-         qcqpOut__11,
-         qcqpOut__12,
-         qcqpOut__13,
-         qcqpOut__14,
-         qcqpOut__15,
-         qcqpOut__16,
-         qcqpOut__17,
-         qcqpOut__18,
-         qcqpOut__19,
-         qcqpOut__2,
-         qcqpOut__20,
-         qcqpOut__23,
-         qcqpOut__24,
-         qcqpOut__25,
-         qcqpOut__26,
-         qcqpOut__27,
-         qcqpOut__28,
-         qcqpOut__29,
-         qcqpOut__3,
-         qcqpOut__4,
-         qcqpOut__5,
-         qcqpOut__6,
-         qcqpOut__7,
-         qcqpOut__8,
-         qcqpOut__9,
-         qpIn__0,
-         qpIn__1,
-         qpIn__10,
-         qpIn__11,
-         qpIn__12,
-         qpIn__13,
-         qpIn__14,
-         qpIn__15,
-         qpIn__16,
-         qpIn__17,
-         qpIn__18,
-         qpIn__19,
-         qpIn__2,
-         qpIn__20,
-         qpIn__21,
-         qpIn__22,
-         qpIn__23,
-         qpIn__24,
-         qpIn__25,
-         qpIn__26,
-         qpIn__27,
-         qpIn__28,
-         qpIn__29,
-         qpIn__3,
-         qpIn__30,
-         qpIn__31,
-         qpIn__32,
-         qpIn__33,
-         qpIn__34,
-         qpIn__35,
-         qpIn__36,
-         qpIn__37,
-         qpIn__38,
-         qpIn__39,
-         qpIn__4,
-         qpIn__40,
-         qpIn__41,
-         qpIn__42,
-         qpIn__43,
-         qpIn__44,
-         qpIn__45,
-         qpIn__46,
-         qpIn__47,
-         qpIn__48,
-         qpIn__49,
-         qpIn__5,
-         qpIn__50,
-         qpIn__53,
-         qpIn__54,
-         qpIn__55,
-         qpIn__56,
-         qpIn__57,
-         qpIn__58,
-         qpIn__59,
-         qpIn__6,
-         qpIn__60,
-         qpIn__61,
-         qpIn__62,
-         qpIn__63,
-         qpIn__64,
-         qpIn__65,
-         qpIn__66,
-         qpIn__67,
-         qpIn__68,
-         qpIn__69,
-         qpIn__7,
-         qpIn__8,
-         qpIn__9,
-         qpOut__0,
-         qpOut__1,
-         qpOut__10,
-         qpOut__11,
-         qpOut__12,
-         qpOut__13,
-         qpOut__14,
-         qpOut__15,
-         qpOut__16,
-         qpOut__17,
-         qpOut__18,
-         qpOut__19,
-         qpOut__2,
-         qpOut__20,
-         qpOut__23,
-         qpOut__24,
-         qpOut__25,
-         qpOut__26,
-         qpOut__27,
-         qpOut__28,
-         qpOut__29,
-         qpOut__3,
-         qpOut__4,
-         qpOut__5,
-         qpOut__6,
-         qpOut__7,
-         qpOut__8,
-         qpOut__9,
-         rdaeIn__0,
-         rdaeIn__1,
-         rdaeIn__10,
-         rdaeIn__11,
-         rdaeIn__12,
-         rdaeIn__13,
-         rdaeIn__14,
-         rdaeIn__15,
-         rdaeIn__16,
-         rdaeIn__17,
-         rdaeIn__18,
-         rdaeIn__19,
-         rdaeIn__2,
-         rdaeIn__20,
-         rdaeIn__21,
-         rdaeIn__22,
-         rdaeIn__23,
-         rdaeIn__24,
-         rdaeIn__25,
-         rdaeIn__26,
-         rdaeIn__27,
-         rdaeIn__28,
-         rdaeIn__29,
-         rdaeIn__3,
-         rdaeIn__30,
-         rdaeIn__31,
-         rdaeIn__32,
-         rdaeIn__33,
-         rdaeIn__34,
-         rdaeIn__35,
-         rdaeIn__36,
-         rdaeIn__37,
-         rdaeIn__38,
-         rdaeIn__4,
-         rdaeIn__41,
-         rdaeIn__42,
-         rdaeIn__43,
-         rdaeIn__44,
-         rdaeIn__45,
-         rdaeIn__46,
-         rdaeIn__47,
-         rdaeIn__48,
-         rdaeIn__49,
-         rdaeIn__5,
-         rdaeIn__50,
-         rdaeIn__51,
-         rdaeIn__52,
-         rdaeIn__53,
-         rdaeIn__6,
-         rdaeIn__7,
-         rdaeIn__8,
-         rdaeIn__9,
-         rdaeOut__0,
-         rdaeOut__1,
-         rdaeOut__10,
-         rdaeOut__11,
-         rdaeOut__12,
-         rdaeOut__13,
-         rdaeOut__14,
-         rdaeOut__17,
-         rdaeOut__18,
-         rdaeOut__19,
-         rdaeOut__2,
-         rdaeOut__20,
-         rdaeOut__21,
-         rdaeOut__3,
-         rdaeOut__4,
-         rdaeOut__5,
-         rdaeOut__6,
-         rdaeOut__7,
-         rdaeOut__8,
-         rdaeOut__9,
-         sdpIn__0,
-         sdpIn__1,
-         sdpIn__10,
-         sdpIn__11,
-         sdpIn__12,
-         sdpIn__13,
-         sdpIn__14,
-         sdpIn__15,
-         sdpIn__16,
-         sdpIn__17,
-         sdpIn__18,
-         sdpIn__19,
-         sdpIn__2,
-         sdpIn__20,
-         sdpIn__21,
-         sdpIn__22,
-         sdpIn__23,
-         sdpIn__24,
-         sdpIn__25,
-         sdpIn__26,
-         sdpIn__27,
-         sdpIn__28,
-         sdpIn__29,
-         sdpIn__3,
-         sdpIn__30,
-         sdpIn__31,
-         sdpIn__32,
-         sdpIn__33,
-         sdpIn__34,
-         sdpIn__35,
-         sdpIn__36,
-         sdpIn__37,
-         sdpIn__38,
-         sdpIn__39,
-         sdpIn__4,
-         sdpIn__40,
-         sdpIn__41,
-         sdpIn__42,
-         sdpIn__43,
-         sdpIn__44,
-         sdpIn__47,
-         sdpIn__48,
-         sdpIn__49,
-         sdpIn__5,
-         sdpIn__50,
-         sdpIn__51,
-         sdpIn__52,
-         sdpIn__53,
-         sdpIn__54,
-         sdpIn__55,
-         sdpIn__56,
-         sdpIn__57,
-         sdpIn__58,
-         sdpIn__59,
-         sdpIn__6,
-         sdpIn__60,
-         sdpIn__61,
-         sdpIn__7,
-         sdpIn__8,
-         sdpIn__9,
-         sdpOut__0,
-         sdpOut__1,
-         sdpOut__10,
-         sdpOut__11,
-         sdpOut__12,
-         sdpOut__13,
-         sdpOut__14,
-         sdpOut__15,
-         sdpOut__16,
-         sdpOut__17,
-         sdpOut__18,
-         sdpOut__19,
-         sdpOut__2,
-         sdpOut__20,
-         sdpOut__21,
-         sdpOut__22,
-         sdpOut__23,
-         sdpOut__24,
-         sdpOut__25,
-         sdpOut__26,
-         sdpOut__27,
-         sdpOut__28,
-         sdpOut__29,
-         sdpOut__3,
-         sdpOut__30,
-         sdpOut__31,
-         sdpOut__32,
-         sdpOut__33,
-         sdpOut__34,
-         sdpOut__35,
-         sdpOut__36,
-         sdpOut__37,
-         sdpOut__38,
-         sdpOut__4,
-         sdpOut__41,
-         sdpOut__42,
-         sdpOut__43,
-         sdpOut__44,
-         sdpOut__45,
-         sdpOut__46,
-         sdpOut__47,
-         sdpOut__48,
-         sdpOut__49,
-         sdpOut__5,
-         sdpOut__50,
-         sdpOut__51,
-         sdpOut__52,
-         sdpOut__53,
-         sdpOut__6,
-         sdpOut__7,
-         sdpOut__8,
-         sdpOut__9,
-         sdqpIn__0,
-         sdqpIn__1,
-         sdqpIn__10,
-         sdqpIn__11,
-         sdqpIn__12,
-         sdqpIn__13,
-         sdqpIn__14,
-         sdqpIn__15,
-         sdqpIn__16,
-         sdqpIn__17,
-         sdqpIn__18,
-         sdqpIn__19,
-         sdqpIn__2,
-         sdqpIn__20,
-         sdqpIn__21,
-         sdqpIn__22,
-         sdqpIn__23,
-         sdqpIn__24,
-         sdqpIn__25,
-         sdqpIn__26,
-         sdqpIn__27,
-         sdqpIn__28,
-         sdqpIn__29,
-         sdqpIn__3,
-         sdqpIn__30,
-         sdqpIn__31,
-         sdqpIn__32,
-         sdqpIn__33,
-         sdqpIn__34,
-         sdqpIn__35,
-         sdqpIn__36,
-         sdqpIn__37,
-         sdqpIn__38,
-         sdqpIn__39,
-         sdqpIn__4,
-         sdqpIn__40,
-         sdqpIn__41,
-         sdqpIn__42,
-         sdqpIn__43,
-         sdqpIn__44,
-         sdqpIn__45,
-         sdqpIn__46,
-         sdqpIn__47,
-         sdqpIn__48,
-         sdqpIn__49,
-         sdqpIn__5,
-         sdqpIn__50,
-         sdqpIn__53,
-         sdqpIn__54,
-         sdqpIn__55,
-         sdqpIn__56,
-         sdqpIn__57,
-         sdqpIn__58,
-         sdqpIn__59,
-         sdqpIn__6,
-         sdqpIn__60,
-         sdqpIn__61,
-         sdqpIn__62,
-         sdqpIn__63,
-         sdqpIn__64,
-         sdqpIn__65,
-         sdqpIn__66,
-         sdqpIn__67,
-         sdqpIn__68,
-         sdqpIn__69,
-         sdqpIn__7,
-         sdqpIn__8,
-         sdqpIn__9,
-         sdqpOut__0,
-         sdqpOut__1,
-         sdqpOut__10,
-         sdqpOut__11,
-         sdqpOut__12,
-         sdqpOut__13,
-         sdqpOut__14,
-         sdqpOut__15,
-         sdqpOut__16,
-         sdqpOut__17,
-         sdqpOut__18,
-         sdqpOut__19,
-         sdqpOut__2,
-         sdqpOut__20,
-         sdqpOut__21,
-         sdqpOut__22,
-         sdqpOut__23,
-         sdqpOut__24,
-         sdqpOut__25,
-         sdqpOut__26,
-         sdqpOut__27,
-         sdqpOut__28,
-         sdqpOut__29,
-         sdqpOut__3,
-         sdqpOut__30,
-         sdqpOut__31,
-         sdqpOut__32,
-         sdqpOut__33,
-         sdqpOut__34,
-         sdqpOut__35,
-         sdqpOut__36,
-         sdqpOut__37,
-         sdqpOut__38,
-         sdqpOut__4,
-         sdqpOut__41,
-         sdqpOut__42,
-         sdqpOut__43,
-         sdqpOut__44,
-         sdqpOut__45,
-         sdqpOut__46,
-         sdqpOut__47,
-         sdqpOut__48,
-         sdqpOut__49,
-         sdqpOut__5,
-         sdqpOut__50,
-         sdqpOut__51,
-         sdqpOut__52,
-         sdqpOut__53,
-         sdqpOut__6,
-         sdqpOut__7,
-         sdqpOut__8,
-         sdqpOut__9,
-         simpleIRK__0,
-         simpleIRK__1,
-         simpleIRK__2,
-         simpleIRK__3,
-         simpleIRK__4,
-         simpleIRK__5,
-         simpleIntegrator__0,
-         simpleIntegrator__1,
-         simpleIntegrator__2,
-         simpleRK__0,
-         simpleRK__1,
-         simpleRK__2,
-         socpIn__0,
-         socpIn__1,
-         socpIn__10,
-         socpIn__11,
-         socpIn__12,
-         socpIn__13,
-         socpIn__14,
-         socpIn__15,
-         socpIn__16,
-         socpIn__17,
-         socpIn__18,
-         socpIn__19,
-         socpIn__2,
-         socpIn__20,
-         socpIn__21,
-         socpIn__22,
-         socpIn__23,
-         socpIn__24,
-         socpIn__25,
-         socpIn__26,
-         socpIn__27,
-         socpIn__28,
-         socpIn__29,
-         socpIn__3,
-         socpIn__30,
-         socpIn__31,
-         socpIn__32,
-         socpIn__33,
-         socpIn__34,
-         socpIn__35,
-         socpIn__36,
-         socpIn__37,
-         socpIn__38,
-         socpIn__39,
-         socpIn__4,
-         socpIn__40,
-         socpIn__41,
-         socpIn__42,
-         socpIn__43,
-         socpIn__44,
-         socpIn__45,
-         socpIn__46,
-         socpIn__47,
-         socpIn__48,
-         socpIn__49,
-         socpIn__5,
-         socpIn__50,
-         socpIn__51,
-         socpIn__52,
-         socpIn__53,
-         socpIn__54,
-         socpIn__55,
-         socpIn__56,
-         socpIn__59,
-         socpIn__6,
-         socpIn__60,
-         socpIn__61,
-         socpIn__62,
-         socpIn__63,
-         socpIn__64,
-         socpIn__65,
-         socpIn__66,
-         socpIn__67,
-         socpIn__68,
-         socpIn__69,
-         socpIn__7,
-         socpIn__70,
-         socpIn__71,
-         socpIn__72,
-         socpIn__73,
-         socpIn__74,
-         socpIn__75,
-         socpIn__76,
-         socpIn__77,
-         socpIn__8,
-         socpIn__9,
-         socpOut__0,
-         socpOut__1,
-         socpOut__10,
-         socpOut__11,
-         socpOut__12,
-         socpOut__13,
-         socpOut__14,
-         socpOut__15,
-         socpOut__16,
-         socpOut__17,
-         socpOut__18,
-         socpOut__19,
-         socpOut__2,
-         socpOut__20,
-         socpOut__21,
-         socpOut__22,
-         socpOut__23,
-         socpOut__24,
-         socpOut__25,
-         socpOut__26,
-         socpOut__27,
-         socpOut__28,
-         socpOut__29,
-         socpOut__3,
-         socpOut__30,
-         socpOut__31,
-         socpOut__32,
-         socpOut__35,
-         socpOut__36,
-         socpOut__37,
-         socpOut__38,
-         socpOut__39,
-         socpOut__4,
-         socpOut__40,
-         socpOut__41,
-         socpOut__42,
-         socpOut__43,
-         socpOut__44,
-         socpOut__45,
-         socpOut__5,
-         socpOut__6,
-         socpOut__7,
-         socpOut__8,
-         socpOut__9,
-         socpStruct__2,
-         socpStruct__3,
-         socpStruct__4,
-         socpStruct__5,
-         socpStruct__6,
-         stabilizedQpIn__0,
-         stabilizedQpIn__1,
-         stabilizedQpIn__10,
-         stabilizedQpIn__11,
-         stabilizedQpIn__12,
-         stabilizedQpIn__13,
-         stabilizedQpIn__14,
-         stabilizedQpIn__15,
-         stabilizedQpIn__16,
-         stabilizedQpIn__17,
-         stabilizedQpIn__18,
-         stabilizedQpIn__19,
-         stabilizedQpIn__2,
-         stabilizedQpIn__20,
-         stabilizedQpIn__21,
-         stabilizedQpIn__22,
-         stabilizedQpIn__23,
-         stabilizedQpIn__24,
-         stabilizedQpIn__25,
-         stabilizedQpIn__26,
-         stabilizedQpIn__27,
-         stabilizedQpIn__28,
-         stabilizedQpIn__29,
-         stabilizedQpIn__3,
-         stabilizedQpIn__30,
-         stabilizedQpIn__31,
-         stabilizedQpIn__32,
-         stabilizedQpIn__33,
-         stabilizedQpIn__34,
-         stabilizedQpIn__35,
-         stabilizedQpIn__36,
-         stabilizedQpIn__37,
-         stabilizedQpIn__38,
-         stabilizedQpIn__39,
-         stabilizedQpIn__4,
-         stabilizedQpIn__40,
-         stabilizedQpIn__41,
-         stabilizedQpIn__42,
-         stabilizedQpIn__43,
-         stabilizedQpIn__44,
-         stabilizedQpIn__45,
-         stabilizedQpIn__46,
-         stabilizedQpIn__47,
-         stabilizedQpIn__48,
-         stabilizedQpIn__49,
-         stabilizedQpIn__5,
-         stabilizedQpIn__50,
-         stabilizedQpIn__51,
-         stabilizedQpIn__52,
-         stabilizedQpIn__53,
-         stabilizedQpIn__54,
-         stabilizedQpIn__55,
-         stabilizedQpIn__56,
-         stabilizedQpIn__57,
-         stabilizedQpIn__58,
-         stabilizedQpIn__59,
-         stabilizedQpIn__6,
-         stabilizedQpIn__60,
-         stabilizedQpIn__61,
-         stabilizedQpIn__62,
-         stabilizedQpIn__63,
-         stabilizedQpIn__64,
-         stabilizedQpIn__65,
-         stabilizedQpIn__66,
-         stabilizedQpIn__67,
-         stabilizedQpIn__68,
-         stabilizedQpIn__7,
-         stabilizedQpIn__71,
-         stabilizedQpIn__72,
-         stabilizedQpIn__73,
-         stabilizedQpIn__74,
-         stabilizedQpIn__75,
-         stabilizedQpIn__76,
-         stabilizedQpIn__77,
-         stabilizedQpIn__78,
-         stabilizedQpIn__79,
-         stabilizedQpIn__8,
-         stabilizedQpIn__80,
-         stabilizedQpIn__81,
-         stabilizedQpIn__82,
-         stabilizedQpIn__83,
-         stabilizedQpIn__84,
-         stabilizedQpIn__85,
-         stabilizedQpIn__86,
-         stabilizedQpIn__87,
-         stabilizedQpIn__88,
-         stabilizedQpIn__89,
-         stabilizedQpIn__9,
-         stabilizedQpIn__90,
-         stabilizedQpIn__91,
-         stabilizedQpIn__92,
-         stabilizedQpIn__93,
-       ) where
-
-
-import Data.Vector ( Vector )
-import qualified Data.Map as M
-import Foreign.C.Types
-import Foreign.Marshal ( new, free )
-import Foreign.Storable ( peek )
-import Foreign.Ptr ( Ptr, nullPtr )
-
-import Casadi.Core.Data
-import Casadi.Core.Enums
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdMap, StdVec, StdString, StdPair )
-import Casadi.Internal.Marshal ( withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-foreign import ccall unsafe "IOScheme__0" c_IOScheme__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__0
-  :: String -> IO (Vector String)
-iOScheme__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__1" c_IOScheme__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__1
-  :: String -> String -> IO (Vector String)
-iOScheme__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__2" c_IOScheme__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__2
-  :: String -> String -> String -> IO (Vector String)
-iOScheme__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__3" c_IOScheme__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__3
-  :: String -> String -> String -> String -> IO (Vector String)
-iOScheme__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__4" c_IOScheme__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__4
-  :: String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__4 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__4 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__5" c_IOScheme__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__5
-  :: String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__5 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__5 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__6" c_IOScheme__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__6
-  :: String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__6 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__7" c_IOScheme__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__7
-  :: String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__7 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__8" c_IOScheme__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__8
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__9" c_IOScheme__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__9
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__10" c_IOScheme__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__10
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__11" c_IOScheme__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__11
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__12" c_IOScheme__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__12
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__13" c_IOScheme__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__13
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__14" c_IOScheme__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__14
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__15" c_IOScheme__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__15
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__16" c_IOScheme__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__16
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__17" c_IOScheme__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__17
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__18" c_IOScheme__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__18
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__19" c_IOScheme__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__19
-  :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String)
-iOScheme__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__20" c_IOScheme__20
-  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__20
-  :: IO (Vector String)
-iOScheme__20  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__20 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__21" c_IOScheme__21
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__21
-  :: Vector String -> IO (Vector String)
-iOScheme__21 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__21 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__22" c_IOScheme__22
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__22
-  :: Vector String -> Vector String -> IO (Vector String)
-iOScheme__22 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__22 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "IOScheme__23" c_IOScheme__23
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec (Ptr StdString)))
-iOScheme__23
-  :: InputOutputScheme -> IO (Vector String)
-iOScheme__23 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_IOScheme__23 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_abs__0" c_casadi_abs__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_abs__0
-  :: SX -> IO SX
-casadi_abs__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_abs__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_abs__1" c_casadi_abs__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_abs__1
-  :: DMatrix -> IO DMatrix
-casadi_abs__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_abs__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_abs__2" c_casadi_abs__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_abs__2
-  :: IMatrix -> IO IMatrix
-casadi_abs__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_abs__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_abs__3" c_casadi_abs__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_abs__3
-  :: MX -> IO MX
-casadi_abs__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_abs__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acos__0" c_casadi_acos__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_acos__0
-  :: SX -> IO SX
-casadi_acos__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acos__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acos__1" c_casadi_acos__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_acos__1
-  :: DMatrix -> IO DMatrix
-casadi_acos__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acos__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acos__2" c_casadi_acos__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_acos__2
-  :: IMatrix -> IO IMatrix
-casadi_acos__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acos__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acos__3" c_casadi_acos__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_acos__3
-  :: MX -> IO MX
-casadi_acos__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acos__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acosh__0" c_casadi_acosh__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_acosh__0
-  :: SX -> IO SX
-casadi_acosh__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acosh__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acosh__1" c_casadi_acosh__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_acosh__1
-  :: DMatrix -> IO DMatrix
-casadi_acosh__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acosh__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acosh__2" c_casadi_acosh__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_acosh__2
-  :: IMatrix -> IO IMatrix
-casadi_acosh__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acosh__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_acosh__3" c_casadi_acosh__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_acosh__3
-  :: MX -> IO MX
-casadi_acosh__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_acosh__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_adj__0" c_casadi_adj__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_adj__0
-  :: SX -> IO SX
-casadi_adj__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_adj__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_adj__1" c_casadi_adj__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_adj__1
-  :: DMatrix -> IO DMatrix
-casadi_adj__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_adj__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_adj__2" c_casadi_adj__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_adj__2
-  :: IMatrix -> IO IMatrix
-casadi_adj__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_adj__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_all__0" c_casadi_all__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_all__0
-  :: SX -> IO SX
-casadi_all__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_all__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_all__1" c_casadi_all__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_all__1
-  :: DMatrix -> IO DMatrix
-casadi_all__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_all__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_all__2" c_casadi_all__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_all__2
-  :: IMatrix -> IO IMatrix
-casadi_all__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_all__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_and__0" c_casadi_and__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_and__0
-  :: SX -> SX -> IO SX
-casadi_and__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_and__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_and__1" c_casadi_and__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_and__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_and__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_and__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_and__2" c_casadi_and__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_and__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_and__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_and__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_and__3" c_casadi_and__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_and__3
-  :: MX -> MX -> IO MX
-casadi_and__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_and__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_any__0" c_casadi_any__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_any__0
-  :: SX -> IO SX
-casadi_any__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_any__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_any__1" c_casadi_any__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_any__1
-  :: DMatrix -> IO DMatrix
-casadi_any__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_any__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_any__2" c_casadi_any__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_any__2
-  :: IMatrix -> IO IMatrix
-casadi_any__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_any__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asin__0" c_casadi_asin__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_asin__0
-  :: SX -> IO SX
-casadi_asin__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asin__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asin__1" c_casadi_asin__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_asin__1
-  :: DMatrix -> IO DMatrix
-casadi_asin__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asin__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asin__2" c_casadi_asin__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_asin__2
-  :: IMatrix -> IO IMatrix
-casadi_asin__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asin__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asin__3" c_casadi_asin__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_asin__3
-  :: MX -> IO MX
-casadi_asin__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asin__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asinh__0" c_casadi_asinh__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_asinh__0
-  :: SX -> IO SX
-casadi_asinh__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asinh__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asinh__1" c_casadi_asinh__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_asinh__1
-  :: DMatrix -> IO DMatrix
-casadi_asinh__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asinh__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asinh__2" c_casadi_asinh__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_asinh__2
-  :: IMatrix -> IO IMatrix
-casadi_asinh__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asinh__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_asinh__3" c_casadi_asinh__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_asinh__3
-  :: MX -> IO MX
-casadi_asinh__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_asinh__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan__0" c_casadi_atan__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_atan__0
-  :: SX -> IO SX
-casadi_atan__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan__1" c_casadi_atan__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_atan__1
-  :: DMatrix -> IO DMatrix
-casadi_atan__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan__2" c_casadi_atan__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_atan__2
-  :: IMatrix -> IO IMatrix
-casadi_atan__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan__3" c_casadi_atan__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_atan__3
-  :: MX -> IO MX
-casadi_atan__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan2__0" c_casadi_atan2__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_atan2__0
-  :: SX -> SX -> IO SX
-casadi_atan2__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan2__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan2__1" c_casadi_atan2__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_atan2__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_atan2__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan2__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan2__2" c_casadi_atan2__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_atan2__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_atan2__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan2__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atan2__3" c_casadi_atan2__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_atan2__3
-  :: MX -> MX -> IO MX
-casadi_atan2__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atan2__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atanh__0" c_casadi_atanh__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_atanh__0
-  :: SX -> IO SX
-casadi_atanh__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atanh__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atanh__1" c_casadi_atanh__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_atanh__1
-  :: DMatrix -> IO DMatrix
-casadi_atanh__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atanh__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atanh__2" c_casadi_atanh__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_atanh__2
-  :: IMatrix -> IO IMatrix
-casadi_atanh__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atanh__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_atanh__3" c_casadi_atanh__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_atanh__3
-  :: MX -> IO MX
-casadi_atanh__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_atanh__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__0" c_casadi_blockcat__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_blockcat__0
-  :: SX -> SX -> SX -> SX -> IO SX
-casadi_blockcat__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__1" c_casadi_blockcat__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO (Ptr SX')
-casadi_blockcat__1
-  :: Vector (Vector SX) -> IO SX
-casadi_blockcat__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__2" c_casadi_blockcat__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_blockcat__2
-  :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_blockcat__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__3" c_casadi_blockcat__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO (Ptr DMatrix')
-casadi_blockcat__3
-  :: Vector (Vector DMatrix) -> IO DMatrix
-casadi_blockcat__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__4" c_casadi_blockcat__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_blockcat__4
-  :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_blockcat__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__5" c_casadi_blockcat__5
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))) -> IO (Ptr IMatrix')
-casadi_blockcat__5
-  :: Vector (Vector IMatrix) -> IO IMatrix
-casadi_blockcat__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__6" c_casadi_blockcat__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_blockcat__6
-  :: MX -> MX -> MX -> MX -> IO MX
-casadi_blockcat__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__7" c_casadi_blockcat__7
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr MX')
-casadi_blockcat__7
-  :: Vector (Vector MX) -> IO MX
-casadi_blockcat__7 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__7 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__8" c_casadi_blockcat__8
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_blockcat__8
-  :: Sparsity -> Sparsity -> Sparsity -> Sparsity -> IO Sparsity
-casadi_blockcat__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blockcat__9" c_casadi_blockcat__9
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr Sparsity')
-casadi_blockcat__9
-  :: Vector (Vector Sparsity) -> IO Sparsity
-casadi_blockcat__9 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blockcat__9 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__0" c_casadi_blocksplit__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-casadi_blocksplit__0
-  :: SX -> IO (Vector (Vector SX))
-casadi_blocksplit__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__1" c_casadi_blocksplit__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-casadi_blocksplit__1
-  :: SX -> Int -> IO (Vector (Vector SX))
-casadi_blocksplit__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__2" c_casadi_blocksplit__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-casadi_blocksplit__2
-  :: SX -> Int -> Int -> IO (Vector (Vector SX))
-casadi_blocksplit__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__3" c_casadi_blocksplit__3
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-casadi_blocksplit__3
-  :: SX -> Vector Int -> Vector Int -> IO (Vector (Vector SX))
-casadi_blocksplit__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__4" c_casadi_blocksplit__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-casadi_blocksplit__4
-  :: DMatrix -> IO (Vector (Vector DMatrix))
-casadi_blocksplit__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__5" c_casadi_blocksplit__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-casadi_blocksplit__5
-  :: DMatrix -> Int -> IO (Vector (Vector DMatrix))
-casadi_blocksplit__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__6" c_casadi_blocksplit__6
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-casadi_blocksplit__6
-  :: DMatrix -> Int -> Int -> IO (Vector (Vector DMatrix))
-casadi_blocksplit__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__7" c_casadi_blocksplit__7
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-casadi_blocksplit__7
-  :: DMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix))
-casadi_blocksplit__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__8" c_casadi_blocksplit__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-casadi_blocksplit__8
-  :: IMatrix -> IO (Vector (Vector IMatrix))
-casadi_blocksplit__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__9" c_casadi_blocksplit__9
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-casadi_blocksplit__9
-  :: IMatrix -> Int -> IO (Vector (Vector IMatrix))
-casadi_blocksplit__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__10" c_casadi_blocksplit__10
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-casadi_blocksplit__10
-  :: IMatrix -> Int -> Int -> IO (Vector (Vector IMatrix))
-casadi_blocksplit__10 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__10 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__11" c_casadi_blocksplit__11
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-casadi_blocksplit__11
-  :: IMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix))
-casadi_blocksplit__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__12" c_casadi_blocksplit__12
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi_blocksplit__12
-  :: MX -> IO (Vector (Vector MX))
-casadi_blocksplit__12 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__12 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__13" c_casadi_blocksplit__13
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi_blocksplit__13
-  :: MX -> Int -> IO (Vector (Vector MX))
-casadi_blocksplit__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__14" c_casadi_blocksplit__14
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi_blocksplit__14
-  :: MX -> Int -> Int -> IO (Vector (Vector MX))
-casadi_blocksplit__14 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__14 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__15" c_casadi_blocksplit__15
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-casadi_blocksplit__15
-  :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX))
-casadi_blocksplit__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__16" c_casadi_blocksplit__16
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
-casadi_blocksplit__16
-  :: Sparsity -> IO (Vector (Vector Sparsity))
-casadi_blocksplit__16 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__16 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__17" c_casadi_blocksplit__17
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
-casadi_blocksplit__17
-  :: Sparsity -> Int -> IO (Vector (Vector Sparsity))
-casadi_blocksplit__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__18" c_casadi_blocksplit__18
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
-casadi_blocksplit__18
-  :: Sparsity -> Int -> Int -> IO (Vector (Vector Sparsity))
-casadi_blocksplit__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_blocksplit__19" c_casadi_blocksplit__19
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
-casadi_blocksplit__19
-  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector (Vector Sparsity))
-casadi_blocksplit__19 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_blocksplit__19 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ceil__0" c_casadi_ceil__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_ceil__0
-  :: SX -> IO SX
-casadi_ceil__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ceil__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ceil__1" c_casadi_ceil__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_ceil__1
-  :: DMatrix -> IO DMatrix
-casadi_ceil__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ceil__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ceil__2" c_casadi_ceil__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_ceil__2
-  :: IMatrix -> IO IMatrix
-casadi_ceil__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ceil__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ceil__3" c_casadi_ceil__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_ceil__3
-  :: MX -> IO MX
-casadi_ceil__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ceil__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_chol__0" c_casadi_chol__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_chol__0
-  :: SX -> IO SX
-casadi_chol__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_chol__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_chol__1" c_casadi_chol__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_chol__1
-  :: DMatrix -> IO DMatrix
-casadi_chol__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_chol__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_chol__2" c_casadi_chol__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_chol__2
-  :: IMatrix -> IO IMatrix
-casadi_chol__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_chol__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cofactor__0" c_casadi_cofactor__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-casadi_cofactor__0
-  :: SX -> Int -> Int -> IO SX
-casadi_cofactor__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cofactor__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cofactor__1" c_casadi_cofactor__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi_cofactor__1
-  :: DMatrix -> Int -> Int -> IO DMatrix
-casadi_cofactor__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cofactor__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cofactor__2" c_casadi_cofactor__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi_cofactor__2
-  :: IMatrix -> Int -> Int -> IO IMatrix
-casadi_cofactor__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cofactor__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__0" c_casadi_conditional__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> Ptr SX' -> IO (Ptr SX')
-casadi_conditional__0
-  :: SX -> Vector SX -> SX -> IO SX
-casadi_conditional__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__1" c_casadi_conditional__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_conditional__1
-  :: SX -> Vector SX -> SX -> Bool -> IO SX
-casadi_conditional__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__2" c_casadi_conditional__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_conditional__2
-  :: DMatrix -> Vector DMatrix -> DMatrix -> IO DMatrix
-casadi_conditional__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__3" c_casadi_conditional__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_conditional__3
-  :: DMatrix -> Vector DMatrix -> DMatrix -> Bool -> IO DMatrix
-casadi_conditional__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__4" c_casadi_conditional__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr IMatrix')) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_conditional__4
-  :: IMatrix -> Vector IMatrix -> IMatrix -> IO IMatrix
-casadi_conditional__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__5" c_casadi_conditional__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr IMatrix')) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_conditional__5
-  :: IMatrix -> Vector IMatrix -> IMatrix -> Bool -> IO IMatrix
-casadi_conditional__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__6" c_casadi_conditional__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr MX' -> IO (Ptr MX')
-casadi_conditional__6
-  :: MX -> Vector MX -> MX -> IO MX
-casadi_conditional__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_conditional__7" c_casadi_conditional__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_conditional__7
-  :: MX -> Vector MX -> MX -> Bool -> IO MX
-casadi_conditional__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_conditional__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_constpow__0" c_casadi_constpow__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_constpow__0
-  :: SX -> SX -> IO SX
-casadi_constpow__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_constpow__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_constpow__1" c_casadi_constpow__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_constpow__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_constpow__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_constpow__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_constpow__2" c_casadi_constpow__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_constpow__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_constpow__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_constpow__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_constpow__3" c_casadi_constpow__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_constpow__3
-  :: MX -> MX -> IO MX
-casadi_constpow__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_constpow__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_copysign__0" c_casadi_copysign__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_copysign__0
-  :: SX -> SX -> IO SX
-casadi_copysign__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_copysign__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_copysign__1" c_casadi_copysign__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_copysign__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_copysign__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_copysign__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_copysign__2" c_casadi_copysign__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_copysign__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_copysign__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_copysign__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_copysign__3" c_casadi_copysign__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_copysign__3
-  :: MX -> MX -> IO MX
-casadi_copysign__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_copysign__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cos__0" c_casadi_cos__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_cos__0
-  :: SX -> IO SX
-casadi_cos__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cos__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cos__1" c_casadi_cos__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_cos__1
-  :: DMatrix -> IO DMatrix
-casadi_cos__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cos__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cos__2" c_casadi_cos__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_cos__2
-  :: IMatrix -> IO IMatrix
-casadi_cos__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cos__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cos__3" c_casadi_cos__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_cos__3
-  :: MX -> IO MX
-casadi_cos__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cos__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cosh__0" c_casadi_cosh__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_cosh__0
-  :: SX -> IO SX
-casadi_cosh__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cosh__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cosh__1" c_casadi_cosh__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_cosh__1
-  :: DMatrix -> IO DMatrix
-casadi_cosh__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cosh__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cosh__2" c_casadi_cosh__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_cosh__2
-  :: IMatrix -> IO IMatrix
-casadi_cosh__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cosh__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cosh__3" c_casadi_cosh__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_cosh__3
-  :: MX -> IO MX
-casadi_cosh__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cosh__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_countNodes__0" c_casadi_countNodes__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi_countNodes__0
-  :: SX -> IO Int
-casadi_countNodes__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_countNodes__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_countNodes__1" c_casadi_countNodes__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi_countNodes__1
-  :: DMatrix -> IO Int
-casadi_countNodes__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_countNodes__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_countNodes__2" c_casadi_countNodes__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi_countNodes__2
-  :: IMatrix -> IO Int
-casadi_countNodes__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_countNodes__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_countNodes__3" c_casadi_countNodes__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi_countNodes__3
-  :: MX -> IO Int
-casadi_countNodes__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_countNodes__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__0" c_casadi_cross__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_cross__0
-  :: SX -> SX -> IO SX
-casadi_cross__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__1" c_casadi_cross__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_cross__1
-  :: SX -> SX -> Int -> IO SX
-casadi_cross__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__2" c_casadi_cross__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_cross__2
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_cross__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__3" c_casadi_cross__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_cross__3
-  :: DMatrix -> DMatrix -> Int -> IO DMatrix
-casadi_cross__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__4" c_casadi_cross__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_cross__4
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_cross__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__5" c_casadi_cross__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_cross__5
-  :: IMatrix -> IMatrix -> Int -> IO IMatrix
-casadi_cross__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__6" c_casadi_cross__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_cross__6
-  :: MX -> MX -> IO MX
-casadi_cross__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_cross__7" c_casadi_cross__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_cross__7
-  :: MX -> MX -> Int -> IO MX
-casadi_cross__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_cross__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_densify__0" c_casadi_densify__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_densify__0
-  :: SX -> IO SX
-casadi_densify__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_densify__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_densify__1" c_casadi_densify__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_densify__1
-  :: DMatrix -> IO DMatrix
-casadi_densify__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_densify__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_densify__2" c_casadi_densify__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_densify__2
-  :: IMatrix -> IO IMatrix
-casadi_densify__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_densify__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_densify__3" c_casadi_densify__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_densify__3
-  :: MX -> IO MX
-casadi_densify__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_densify__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_dependsOn__0" c_casadi_dependsOn__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
-casadi_dependsOn__0
-  :: SX -> SX -> IO Bool
-casadi_dependsOn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_dependsOn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_dependsOn__1" c_casadi_dependsOn__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt
-casadi_dependsOn__1
-  :: DMatrix -> DMatrix -> IO Bool
-casadi_dependsOn__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_dependsOn__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_dependsOn__2" c_casadi_dependsOn__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt
-casadi_dependsOn__2
-  :: IMatrix -> IMatrix -> IO Bool
-casadi_dependsOn__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_dependsOn__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_dependsOn__3" c_casadi_dependsOn__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
-casadi_dependsOn__3
-  :: MX -> MX -> IO Bool
-casadi_dependsOn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_dependsOn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_det__0" c_casadi_det__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_det__0
-  :: SX -> IO SX
-casadi_det__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_det__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_det__1" c_casadi_det__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_det__1
-  :: DMatrix -> IO DMatrix
-casadi_det__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_det__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_det__2" c_casadi_det__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_det__2
-  :: IMatrix -> IO IMatrix
-casadi_det__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_det__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_det__3" c_casadi_det__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_det__3
-  :: MX -> IO MX
-casadi_det__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_det__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diag__0" c_casadi_diag__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_diag__0
-  :: SX -> IO SX
-casadi_diag__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diag__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diag__1" c_casadi_diag__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_diag__1
-  :: DMatrix -> IO DMatrix
-casadi_diag__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diag__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diag__2" c_casadi_diag__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_diag__2
-  :: IMatrix -> IO IMatrix
-casadi_diag__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diag__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diag__3" c_casadi_diag__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_diag__3
-  :: MX -> IO MX
-casadi_diag__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diag__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagcat__0" c_casadi_diagcat__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-casadi_diagcat__0
-  :: Vector SX -> IO SX
-casadi_diagcat__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagcat__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagcat__1" c_casadi_diagcat__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-casadi_diagcat__1
-  :: Vector DMatrix -> IO DMatrix
-casadi_diagcat__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagcat__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagcat__2" c_casadi_diagcat__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-casadi_diagcat__2
-  :: Vector IMatrix -> IO IMatrix
-casadi_diagcat__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagcat__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagcat__3" c_casadi_diagcat__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi_diagcat__3
-  :: Vector MX -> IO MX
-casadi_diagcat__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagcat__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagcat__4" c_casadi_diagcat__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-casadi_diagcat__4
-  :: Vector Sparsity -> IO Sparsity
-casadi_diagcat__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagcat__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__0" c_casadi_diagsplit__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi_diagsplit__0
-  :: SX -> Int -> Int -> IO (Vector SX)
-casadi_diagsplit__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__1" c_casadi_diagsplit__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
-casadi_diagsplit__1
-  :: SX -> IO (Vector SX)
-casadi_diagsplit__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__2" c_casadi_diagsplit__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi_diagsplit__2
-  :: SX -> Int -> IO (Vector SX)
-casadi_diagsplit__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__3" c_casadi_diagsplit__3
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
-casadi_diagsplit__3
-  :: SX -> Vector Int -> IO (Vector SX)
-casadi_diagsplit__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__4" c_casadi_diagsplit__4
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
-casadi_diagsplit__4
-  :: SX -> Vector Int -> Vector Int -> IO (Vector SX)
-casadi_diagsplit__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__5" c_casadi_diagsplit__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_diagsplit__5
-  :: DMatrix -> Int -> Int -> IO (Vector DMatrix)
-casadi_diagsplit__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__6" c_casadi_diagsplit__6
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_diagsplit__6
-  :: DMatrix -> IO (Vector DMatrix)
-casadi_diagsplit__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__7" c_casadi_diagsplit__7
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_diagsplit__7
-  :: DMatrix -> Int -> IO (Vector DMatrix)
-casadi_diagsplit__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__8" c_casadi_diagsplit__8
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_diagsplit__8
-  :: DMatrix -> Vector Int -> IO (Vector DMatrix)
-casadi_diagsplit__8 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__8 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__9" c_casadi_diagsplit__9
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_diagsplit__9
-  :: DMatrix -> Vector Int -> Vector Int -> IO (Vector DMatrix)
-casadi_diagsplit__9 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__9 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__10" c_casadi_diagsplit__10
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_diagsplit__10
-  :: IMatrix -> Int -> Int -> IO (Vector IMatrix)
-casadi_diagsplit__10 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__10 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__11" c_casadi_diagsplit__11
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_diagsplit__11
-  :: IMatrix -> IO (Vector IMatrix)
-casadi_diagsplit__11 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__11 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__12" c_casadi_diagsplit__12
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_diagsplit__12
-  :: IMatrix -> Int -> IO (Vector IMatrix)
-casadi_diagsplit__12 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__12 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__13" c_casadi_diagsplit__13
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_diagsplit__13
-  :: IMatrix -> Vector Int -> IO (Vector IMatrix)
-casadi_diagsplit__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__14" c_casadi_diagsplit__14
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_diagsplit__14
-  :: IMatrix -> Vector Int -> Vector Int -> IO (Vector IMatrix)
-casadi_diagsplit__14 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__14 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__15" c_casadi_diagsplit__15
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi_diagsplit__15
-  :: MX -> Int -> Int -> IO (Vector MX)
-casadi_diagsplit__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__16" c_casadi_diagsplit__16
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-casadi_diagsplit__16
-  :: MX -> IO (Vector MX)
-casadi_diagsplit__16 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__16 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__17" c_casadi_diagsplit__17
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi_diagsplit__17
-  :: MX -> Int -> IO (Vector MX)
-casadi_diagsplit__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__18" c_casadi_diagsplit__18
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_diagsplit__18
-  :: MX -> Vector Int -> IO (Vector MX)
-casadi_diagsplit__18 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__18 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__19" c_casadi_diagsplit__19
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_diagsplit__19
-  :: MX -> Vector Int -> Vector Int -> IO (Vector MX)
-casadi_diagsplit__19 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__19 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__20" c_casadi_diagsplit__20
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_diagsplit__20
-  :: Sparsity -> Int -> Int -> IO (Vector Sparsity)
-casadi_diagsplit__20 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__20 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__21" c_casadi_diagsplit__21
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_diagsplit__21
-  :: Sparsity -> IO (Vector Sparsity)
-casadi_diagsplit__21 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__21 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__22" c_casadi_diagsplit__22
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_diagsplit__22
-  :: Sparsity -> Int -> IO (Vector Sparsity)
-casadi_diagsplit__22 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__22 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__23" c_casadi_diagsplit__23
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_diagsplit__23
-  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
-casadi_diagsplit__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_diagsplit__24" c_casadi_diagsplit__24
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_diagsplit__24
-  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Sparsity)
-casadi_diagsplit__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_diagsplit__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_eig_symbolic__0" c_casadi_eig_symbolic__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_eig_symbolic__0
-  :: SX -> IO SX
-casadi_eig_symbolic__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_eig_symbolic__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_eig_symbolic__1" c_casadi_eig_symbolic__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_eig_symbolic__1
-  :: DMatrix -> IO DMatrix
-casadi_eig_symbolic__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_eig_symbolic__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_eig_symbolic__2" c_casadi_eig_symbolic__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_eig_symbolic__2
-  :: IMatrix -> IO IMatrix
-casadi_eig_symbolic__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_eig_symbolic__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_eq__0" c_casadi_eq__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_eq__0
-  :: SX -> SX -> IO SX
-casadi_eq__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_eq__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_eq__1" c_casadi_eq__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_eq__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_eq__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_eq__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_eq__2" c_casadi_eq__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_eq__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_eq__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_eq__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_eq__3" c_casadi_eq__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_eq__3
-  :: MX -> MX -> IO MX
-casadi_eq__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_eq__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erf__0" c_casadi_erf__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_erf__0
-  :: SX -> IO SX
-casadi_erf__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erf__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erf__1" c_casadi_erf__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_erf__1
-  :: DMatrix -> IO DMatrix
-casadi_erf__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erf__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erf__2" c_casadi_erf__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_erf__2
-  :: IMatrix -> IO IMatrix
-casadi_erf__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erf__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erf__3" c_casadi_erf__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_erf__3
-  :: MX -> IO MX
-casadi_erf__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erf__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erfinv__0" c_casadi_erfinv__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_erfinv__0
-  :: SX -> IO SX
-casadi_erfinv__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erfinv__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erfinv__1" c_casadi_erfinv__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_erfinv__1
-  :: DMatrix -> IO DMatrix
-casadi_erfinv__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erfinv__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erfinv__2" c_casadi_erfinv__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_erfinv__2
-  :: IMatrix -> IO IMatrix
-casadi_erfinv__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erfinv__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_erfinv__3" c_casadi_erfinv__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_erfinv__3
-  :: MX -> IO MX
-casadi_erfinv__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_erfinv__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_exp__0" c_casadi_exp__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_exp__0
-  :: SX -> IO SX
-casadi_exp__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_exp__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_exp__1" c_casadi_exp__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_exp__1
-  :: DMatrix -> IO DMatrix
-casadi_exp__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_exp__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_exp__2" c_casadi_exp__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_exp__2
-  :: IMatrix -> IO IMatrix
-casadi_exp__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_exp__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_exp__3" c_casadi_exp__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_exp__3
-  :: MX -> IO MX
-casadi_exp__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_exp__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_expand__0" c_casadi_expand__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
-casadi_expand__0
-  :: SX -> SX -> SX -> IO ()
-casadi_expand__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_expand__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_expand__1" c_casadi_expand__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
-casadi_expand__1
-  :: DMatrix -> DMatrix -> DMatrix -> IO ()
-casadi_expand__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_expand__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_expand__2" c_casadi_expand__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi_expand__2
-  :: IMatrix -> IMatrix -> IMatrix -> IO ()
-casadi_expand__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_expand__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__0" c_casadi_extractShared__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
-casadi_extractShared__0
-  :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> IO ()
-casadi_extractShared__0 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__0 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__1" c_casadi_extractShared__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO ()
-casadi_extractShared__1
-  :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> String -> IO ()
-casadi_extractShared__1 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__1 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__2" c_casadi_extractShared__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO ()
-casadi_extractShared__2
-  :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> String -> String -> IO ()
-casadi_extractShared__2 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__3" c_casadi_extractShared__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO ()
-casadi_extractShared__3
-  :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO ()
-casadi_extractShared__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__4" c_casadi_extractShared__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO ()
-casadi_extractShared__4
-  :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> IO ()
-casadi_extractShared__4 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__4 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__5" c_casadi_extractShared__5
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO ()
-casadi_extractShared__5
-  :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> String -> IO ()
-casadi_extractShared__5 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__5 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__6" c_casadi_extractShared__6
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO ()
-casadi_extractShared__6
-  :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO ()
-casadi_extractShared__6 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__6 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__7" c_casadi_extractShared__7
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> IO ()
-casadi_extractShared__7
-  :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> IO ()
-casadi_extractShared__7 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__7 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__8" c_casadi_extractShared__8
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> Ptr StdString -> IO ()
-casadi_extractShared__8
-  :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> String -> IO ()
-casadi_extractShared__8 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__8 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__9" c_casadi_extractShared__9
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
-casadi_extractShared__9
-  :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> IO ()
-casadi_extractShared__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__10" c_casadi_extractShared__10
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO ()
-casadi_extractShared__10
-  :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> String -> IO ()
-casadi_extractShared__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_extractShared__11" c_casadi_extractShared__11
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO ()
-casadi_extractShared__11
-  :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> String -> String -> IO ()
-casadi_extractShared__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_extractShared__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_find" c_casadi_find
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_find
-  :: MX -> IO MX
-casadi_find x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_find errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_floor__0" c_casadi_floor__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_floor__0
-  :: SX -> IO SX
-casadi_floor__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_floor__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_floor__1" c_casadi_floor__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_floor__1
-  :: DMatrix -> IO DMatrix
-casadi_floor__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_floor__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_floor__2" c_casadi_floor__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_floor__2
-  :: IMatrix -> IO IMatrix
-casadi_floor__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_floor__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_floor__3" c_casadi_floor__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_floor__3
-  :: MX -> IO MX
-casadi_floor__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_floor__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__0" c_casadi_gauss_quadrature__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr SX' -> IO (Ptr SX')
-casadi_gauss_quadrature__0
-  :: SX -> SX -> SX -> SX -> Int -> SX -> IO SX
-casadi_gauss_quadrature__0 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__1" c_casadi_gauss_quadrature__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_gauss_quadrature__1
-  :: SX -> SX -> SX -> SX -> IO SX
-casadi_gauss_quadrature__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__2" c_casadi_gauss_quadrature__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_gauss_quadrature__2
-  :: SX -> SX -> SX -> SX -> Int -> IO SX
-casadi_gauss_quadrature__2 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__3" c_casadi_gauss_quadrature__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_gauss_quadrature__3
-  :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> Int -> DMatrix -> IO DMatrix
-casadi_gauss_quadrature__3 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__3 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__4" c_casadi_gauss_quadrature__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_gauss_quadrature__4
-  :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_gauss_quadrature__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__5" c_casadi_gauss_quadrature__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_gauss_quadrature__5
-  :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix
-casadi_gauss_quadrature__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__6" c_casadi_gauss_quadrature__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_gauss_quadrature__6
-  :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IMatrix -> IO IMatrix
-casadi_gauss_quadrature__6 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__6 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__7" c_casadi_gauss_quadrature__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_gauss_quadrature__7
-  :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_gauss_quadrature__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gauss_quadrature__8" c_casadi_gauss_quadrature__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_gauss_quadrature__8
-  :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix
-casadi_gauss_quadrature__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gauss_quadrature__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ge__0" c_casadi_ge__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_ge__0
-  :: SX -> SX -> IO SX
-casadi_ge__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ge__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ge__1" c_casadi_ge__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_ge__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_ge__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ge__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ge__2" c_casadi_ge__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_ge__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_ge__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ge__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ge__3" c_casadi_ge__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_ge__3
-  :: MX -> MX -> IO MX
-casadi_ge__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ge__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_getMinor__0" c_casadi_getMinor__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-casadi_getMinor__0
-  :: SX -> Int -> Int -> IO SX
-casadi_getMinor__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_getMinor__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_getMinor__1" c_casadi_getMinor__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi_getMinor__1
-  :: DMatrix -> Int -> Int -> IO DMatrix
-casadi_getMinor__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_getMinor__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_getMinor__2" c_casadi_getMinor__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi_getMinor__2
-  :: IMatrix -> Int -> Int -> IO IMatrix
-casadi_getMinor__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_getMinor__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_getOperatorRepresentation__0" c_casadi_getOperatorRepresentation__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
-casadi_getOperatorRepresentation__0
-  :: SX -> Vector String -> IO String
-casadi_getOperatorRepresentation__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_getOperatorRepresentation__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_getOperatorRepresentation__1" c_casadi_getOperatorRepresentation__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
-casadi_getOperatorRepresentation__1
-  :: DMatrix -> Vector String -> IO String
-casadi_getOperatorRepresentation__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_getOperatorRepresentation__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_getOperatorRepresentation__2" c_casadi_getOperatorRepresentation__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
-casadi_getOperatorRepresentation__2
-  :: IMatrix -> Vector String -> IO String
-casadi_getOperatorRepresentation__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_getOperatorRepresentation__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_getOperatorRepresentation__3" c_casadi_getOperatorRepresentation__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
-casadi_getOperatorRepresentation__3
-  :: MX -> Vector String -> IO String
-casadi_getOperatorRepresentation__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_getOperatorRepresentation__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gradient__0" c_casadi_gradient__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_gradient__0
-  :: SX -> SX -> IO SX
-casadi_gradient__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gradient__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gradient__1" c_casadi_gradient__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_gradient__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_gradient__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gradient__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gradient__2" c_casadi_gradient__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_gradient__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_gradient__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gradient__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gradient__3" c_casadi_gradient__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_gradient__3
-  :: MX -> MX -> IO MX
-casadi_gradient__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gradient__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_graph_substitute__0" c_casadi_graph_substitute__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_graph_substitute__0
-  :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
-casadi_graph_substitute__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_graph_substitute__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_graph_substitute__1" c_casadi_graph_substitute__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi_graph_substitute__1
-  :: MX -> Vector MX -> Vector MX -> IO MX
-casadi_graph_substitute__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_graph_substitute__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gt__0" c_casadi_gt__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_gt__0
-  :: SX -> SX -> IO SX
-casadi_gt__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gt__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gt__1" c_casadi_gt__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_gt__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_gt__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gt__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gt__2" c_casadi_gt__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_gt__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_gt__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gt__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_gt__3" c_casadi_gt__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_gt__3
-  :: MX -> MX -> IO MX
-casadi_gt__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_gt__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_heaviside__0" c_casadi_heaviside__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_heaviside__0
-  :: SX -> IO SX
-casadi_heaviside__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_heaviside__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_heaviside__1" c_casadi_heaviside__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_heaviside__1
-  :: DMatrix -> IO DMatrix
-casadi_heaviside__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_heaviside__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_heaviside__2" c_casadi_heaviside__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_heaviside__2
-  :: IMatrix -> IO IMatrix
-casadi_heaviside__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_heaviside__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_hessian__0" c_casadi_hessian__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_hessian__0
-  :: SX -> SX -> SX -> IO SX
-casadi_hessian__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_hessian__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_hessian__1" c_casadi_hessian__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_hessian__1
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_hessian__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_hessian__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_hessian__2" c_casadi_hessian__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_hessian__2
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_hessian__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_hessian__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_hessian__3" c_casadi_hessian__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_hessian__3
-  :: MX -> MX -> MX -> IO MX
-casadi_hessian__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_hessian__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzcat__0" c_casadi_horzcat__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-casadi_horzcat__0
-  :: Vector SX -> IO SX
-casadi_horzcat__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzcat__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzcat__1" c_casadi_horzcat__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-casadi_horzcat__1
-  :: Vector DMatrix -> IO DMatrix
-casadi_horzcat__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzcat__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzcat__2" c_casadi_horzcat__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-casadi_horzcat__2
-  :: Vector IMatrix -> IO IMatrix
-casadi_horzcat__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzcat__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzcat__3" c_casadi_horzcat__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi_horzcat__3
-  :: Vector MX -> IO MX
-casadi_horzcat__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzcat__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzcat__4" c_casadi_horzcat__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-casadi_horzcat__4
-  :: Vector Sparsity -> IO Sparsity
-casadi_horzcat__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzcat__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__0" c_casadi_horzsplit__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
-casadi_horzsplit__0
-  :: SX -> IO (Vector SX)
-casadi_horzsplit__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__1" c_casadi_horzsplit__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi_horzsplit__1
-  :: SX -> Int -> IO (Vector SX)
-casadi_horzsplit__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__2" c_casadi_horzsplit__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
-casadi_horzsplit__2
-  :: SX -> Vector Int -> IO (Vector SX)
-casadi_horzsplit__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__3" c_casadi_horzsplit__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_horzsplit__3
-  :: DMatrix -> IO (Vector DMatrix)
-casadi_horzsplit__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__4" c_casadi_horzsplit__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_horzsplit__4
-  :: DMatrix -> Int -> IO (Vector DMatrix)
-casadi_horzsplit__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__5" c_casadi_horzsplit__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_horzsplit__5
-  :: DMatrix -> Vector Int -> IO (Vector DMatrix)
-casadi_horzsplit__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__6" c_casadi_horzsplit__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_horzsplit__6
-  :: IMatrix -> IO (Vector IMatrix)
-casadi_horzsplit__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__7" c_casadi_horzsplit__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_horzsplit__7
-  :: IMatrix -> Int -> IO (Vector IMatrix)
-casadi_horzsplit__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__8" c_casadi_horzsplit__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_horzsplit__8
-  :: IMatrix -> Vector Int -> IO (Vector IMatrix)
-casadi_horzsplit__8 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__8 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__9" c_casadi_horzsplit__9
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-casadi_horzsplit__9
-  :: MX -> IO (Vector MX)
-casadi_horzsplit__9 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__9 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__10" c_casadi_horzsplit__10
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi_horzsplit__10
-  :: MX -> Int -> IO (Vector MX)
-casadi_horzsplit__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__11" c_casadi_horzsplit__11
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_horzsplit__11
-  :: MX -> Vector Int -> IO (Vector MX)
-casadi_horzsplit__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__12" c_casadi_horzsplit__12
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_horzsplit__12
-  :: Sparsity -> IO (Vector Sparsity)
-casadi_horzsplit__12 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__12 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__13" c_casadi_horzsplit__13
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_horzsplit__13
-  :: Sparsity -> Int -> IO (Vector Sparsity)
-casadi_horzsplit__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_horzsplit__14" c_casadi_horzsplit__14
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_horzsplit__14
-  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
-casadi_horzsplit__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_horzsplit__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__0" c_casadi_if_else__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_if_else__0
-  :: SX -> SX -> SX -> IO SX
-casadi_if_else__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__1" c_casadi_if_else__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_if_else__1
-  :: SX -> SX -> SX -> Bool -> IO SX
-casadi_if_else__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__2" c_casadi_if_else__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_if_else__2
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_if_else__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__3" c_casadi_if_else__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_if_else__3
-  :: DMatrix -> DMatrix -> DMatrix -> Bool -> IO DMatrix
-casadi_if_else__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__4" c_casadi_if_else__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_if_else__4
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_if_else__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__5" c_casadi_if_else__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_if_else__5
-  :: IMatrix -> IMatrix -> IMatrix -> Bool -> IO IMatrix
-casadi_if_else__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__6" c_casadi_if_else__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_if_else__6
-  :: MX -> MX -> MX -> IO MX
-casadi_if_else__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_if_else__7" c_casadi_if_else__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_if_else__7
-  :: MX -> MX -> MX -> Bool -> IO MX
-casadi_if_else__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_if_else__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inner_prod__0" c_casadi_inner_prod__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_inner_prod__0
-  :: SX -> SX -> IO SX
-casadi_inner_prod__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inner_prod__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inner_prod__1" c_casadi_inner_prod__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_inner_prod__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_inner_prod__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inner_prod__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inner_prod__2" c_casadi_inner_prod__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_inner_prod__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_inner_prod__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inner_prod__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inner_prod__3" c_casadi_inner_prod__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_inner_prod__3
-  :: MX -> MX -> IO MX
-casadi_inner_prod__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inner_prod__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inv__0" c_casadi_inv__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_inv__0
-  :: SX -> IO SX
-casadi_inv__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inv__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inv__1" c_casadi_inv__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_inv__1
-  :: DMatrix -> IO DMatrix
-casadi_inv__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inv__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inv__2" c_casadi_inv__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_inv__2
-  :: IMatrix -> IO IMatrix
-casadi_inv__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inv__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_inv__3" c_casadi_inv__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_inv__3
-  :: MX -> IO MX
-casadi_inv__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_inv__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__0" c_casadi_isEqual__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
-casadi_isEqual__0
-  :: SX -> SX -> IO Bool
-casadi_isEqual__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__1" c_casadi_isEqual__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO CInt
-casadi_isEqual__1
-  :: SX -> SX -> Int -> IO Bool
-casadi_isEqual__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__2" c_casadi_isEqual__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt
-casadi_isEqual__2
-  :: DMatrix -> DMatrix -> IO Bool
-casadi_isEqual__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__3" c_casadi_isEqual__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO CInt
-casadi_isEqual__3
-  :: DMatrix -> DMatrix -> Int -> IO Bool
-casadi_isEqual__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__4" c_casadi_isEqual__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt
-casadi_isEqual__4
-  :: IMatrix -> IMatrix -> IO Bool
-casadi_isEqual__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__5" c_casadi_isEqual__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO CInt
-casadi_isEqual__5
-  :: IMatrix -> IMatrix -> Int -> IO Bool
-casadi_isEqual__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__6" c_casadi_isEqual__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
-casadi_isEqual__6
-  :: MX -> MX -> IO Bool
-casadi_isEqual__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_isEqual__7" c_casadi_isEqual__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO CInt
-casadi_isEqual__7
-  :: MX -> MX -> Int -> IO Bool
-casadi_isEqual__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_isEqual__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_iszero__0" c_casadi_iszero__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi_iszero__0
-  :: SX -> IO Bool
-casadi_iszero__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_iszero__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_iszero__1" c_casadi_iszero__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi_iszero__1
-  :: DMatrix -> IO Bool
-casadi_iszero__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_iszero__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_iszero__2" c_casadi_iszero__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi_iszero__2
-  :: IMatrix -> IO Bool
-casadi_iszero__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_iszero__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_iszero__3" c_casadi_iszero__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi_iszero__3
-  :: MX -> IO Bool
-casadi_iszero__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_iszero__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobian__0" c_casadi_jacobian__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_jacobian__0
-  :: SX -> SX -> IO SX
-casadi_jacobian__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobian__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobian__1" c_casadi_jacobian__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_jacobian__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_jacobian__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobian__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobian__2" c_casadi_jacobian__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_jacobian__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_jacobian__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobian__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobian__3" c_casadi_jacobian__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_jacobian__3
-  :: MX -> MX -> IO MX
-casadi_jacobian__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobian__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobianTimesVector__0" c_casadi_jacobianTimesVector__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_jacobianTimesVector__0
-  :: SX -> SX -> SX -> IO SX
-casadi_jacobianTimesVector__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobianTimesVector__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobianTimesVector__1" c_casadi_jacobianTimesVector__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_jacobianTimesVector__1
-  :: SX -> SX -> SX -> Bool -> IO SX
-casadi_jacobianTimesVector__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobianTimesVector__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobianTimesVector__2" c_casadi_jacobianTimesVector__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_jacobianTimesVector__2
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_jacobianTimesVector__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobianTimesVector__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobianTimesVector__3" c_casadi_jacobianTimesVector__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_jacobianTimesVector__3
-  :: DMatrix -> DMatrix -> DMatrix -> Bool -> IO DMatrix
-casadi_jacobianTimesVector__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobianTimesVector__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobianTimesVector__4" c_casadi_jacobianTimesVector__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_jacobianTimesVector__4
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_jacobianTimesVector__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobianTimesVector__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_jacobianTimesVector__5" c_casadi_jacobianTimesVector__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_jacobianTimesVector__5
-  :: IMatrix -> IMatrix -> IMatrix -> Bool -> IO IMatrix
-casadi_jacobianTimesVector__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_jacobianTimesVector__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_kron__0" c_casadi_kron__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_kron__0
-  :: SX -> SX -> IO SX
-casadi_kron__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_kron__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_kron__1" c_casadi_kron__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_kron__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_kron__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_kron__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_kron__2" c_casadi_kron__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_kron__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_kron__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_kron__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_kron__3" c_casadi_kron__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_kron__3
-  :: MX -> MX -> IO MX
-casadi_kron__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_kron__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_kron__4" c_casadi_kron__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_kron__4
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi_kron__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_kron__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ldivide__0" c_casadi_ldivide__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_ldivide__0
-  :: SX -> SX -> IO SX
-casadi_ldivide__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ldivide__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ldivide__1" c_casadi_ldivide__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_ldivide__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_ldivide__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ldivide__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ldivide__2" c_casadi_ldivide__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_ldivide__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_ldivide__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ldivide__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ldivide__3" c_casadi_ldivide__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_ldivide__3
-  :: MX -> MX -> IO MX
-casadi_ldivide__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ldivide__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_le__0" c_casadi_le__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_le__0
-  :: SX -> SX -> IO SX
-casadi_le__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_le__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_le__1" c_casadi_le__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_le__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_le__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_le__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_le__2" c_casadi_le__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_le__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_le__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_le__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_le__3" c_casadi_le__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_le__3
-  :: MX -> MX -> IO MX
-casadi_le__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_le__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_linspace__0" c_casadi_linspace__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_linspace__0
-  :: SX -> SX -> Int -> IO SX
-casadi_linspace__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_linspace__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_linspace__1" c_casadi_linspace__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_linspace__1
-  :: DMatrix -> DMatrix -> Int -> IO DMatrix
-casadi_linspace__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_linspace__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_linspace__2" c_casadi_linspace__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_linspace__2
-  :: IMatrix -> IMatrix -> Int -> IO IMatrix
-casadi_linspace__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_linspace__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_linspace__3" c_casadi_linspace__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_linspace__3
-  :: MX -> MX -> Int -> IO MX
-casadi_linspace__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_linspace__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log__0" c_casadi_log__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_log__0
-  :: SX -> IO SX
-casadi_log__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log__1" c_casadi_log__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_log__1
-  :: DMatrix -> IO DMatrix
-casadi_log__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log__2" c_casadi_log__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_log__2
-  :: IMatrix -> IO IMatrix
-casadi_log__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log__3" c_casadi_log__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_log__3
-  :: MX -> IO MX
-casadi_log__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log10__0" c_casadi_log10__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_log10__0
-  :: SX -> IO SX
-casadi_log10__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log10__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log10__1" c_casadi_log10__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_log10__1
-  :: DMatrix -> IO DMatrix
-casadi_log10__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log10__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log10__2" c_casadi_log10__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_log10__2
-  :: IMatrix -> IO IMatrix
-casadi_log10__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log10__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_log10__3" c_casadi_log10__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_log10__3
-  :: MX -> IO MX
-casadi_log10__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_log10__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_lt__0" c_casadi_lt__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_lt__0
-  :: SX -> SX -> IO SX
-casadi_lt__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_lt__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_lt__1" c_casadi_lt__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_lt__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_lt__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_lt__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_lt__2" c_casadi_lt__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_lt__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_lt__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_lt__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_lt__3" c_casadi_lt__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_lt__3
-  :: MX -> MX -> IO MX
-casadi_lt__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_lt__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mac__0" c_casadi_mac__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_mac__0
-  :: SX -> SX -> SX -> IO SX
-casadi_mac__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mac__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mac__1" c_casadi_mac__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_mac__1
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_mac__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mac__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mac__2" c_casadi_mac__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_mac__2
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_mac__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mac__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mac__3" c_casadi_mac__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_mac__3
-  :: MX -> MX -> MX -> IO MX
-casadi_mac__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mac__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mac__4" c_casadi_mac__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_mac__4
-  :: Sparsity -> Sparsity -> Sparsity -> IO Sparsity
-casadi_mac__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mac__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_matrix_expand__0" c_casadi_matrix_expand__0
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_matrix_expand__0
-  :: MX -> IO MX
-casadi_matrix_expand__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_matrix_expand__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_matrix_expand__1" c_casadi_matrix_expand__1
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi_matrix_expand__1
-  :: MX -> Vector MX -> IO MX
-casadi_matrix_expand__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_matrix_expand__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_matrix_expand__2" c_casadi_matrix_expand__2
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX')
-casadi_matrix_expand__2
-  :: MX -> Vector MX -> M.Map String GenericType -> IO MX
-casadi_matrix_expand__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_matrix_expand__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_matrix_expand__3" c_casadi_matrix_expand__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_matrix_expand__3
-  :: Vector MX -> IO (Vector MX)
-casadi_matrix_expand__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_matrix_expand__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_matrix_expand__4" c_casadi_matrix_expand__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_matrix_expand__4
-  :: Vector MX -> Vector MX -> IO (Vector MX)
-casadi_matrix_expand__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_matrix_expand__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_matrix_expand__5" c_casadi_matrix_expand__5
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_matrix_expand__5
-  :: Vector MX -> Vector MX -> M.Map String GenericType -> IO (Vector MX)
-casadi_matrix_expand__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_matrix_expand__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_max__0" c_casadi_max__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_max__0
-  :: SX -> SX -> IO SX
-casadi_max__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_max__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_max__1" c_casadi_max__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_max__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_max__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_max__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_max__2" c_casadi_max__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_max__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_max__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_max__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_max__3" c_casadi_max__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_max__3
-  :: MX -> MX -> IO MX
-casadi_max__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_max__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_min__0" c_casadi_min__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_min__0
-  :: SX -> SX -> IO SX
-casadi_min__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_min__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_min__1" c_casadi_min__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_min__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_min__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_min__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_min__2" c_casadi_min__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_min__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_min__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_min__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_min__3" c_casadi_min__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_min__3
-  :: MX -> MX -> IO MX
-casadi_min__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_min__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_minus__0" c_casadi_minus__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_minus__0
-  :: SX -> SX -> IO SX
-casadi_minus__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_minus__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_minus__1" c_casadi_minus__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_minus__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_minus__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_minus__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_minus__2" c_casadi_minus__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_minus__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_minus__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_minus__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_minus__3" c_casadi_minus__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_minus__3
-  :: MX -> MX -> IO MX
-casadi_minus__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_minus__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mldivide__0" c_casadi_mldivide__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_mldivide__0
-  :: SX -> SX -> IO SX
-casadi_mldivide__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mldivide__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mldivide__1" c_casadi_mldivide__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_mldivide__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_mldivide__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mldivide__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mldivide__2" c_casadi_mldivide__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_mldivide__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_mldivide__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mldivide__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mldivide__3" c_casadi_mldivide__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_mldivide__3
-  :: MX -> MX -> IO MX
-casadi_mldivide__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mldivide__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mod__0" c_casadi_mod__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_mod__0
-  :: SX -> SX -> IO SX
-casadi_mod__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mod__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mod__1" c_casadi_mod__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_mod__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_mod__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mod__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mod__2" c_casadi_mod__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_mod__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_mod__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mod__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mod__3" c_casadi_mod__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_mod__3
-  :: MX -> MX -> IO MX
-casadi_mod__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mod__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mpower__0" c_casadi_mpower__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_mpower__0
-  :: SX -> SX -> IO SX
-casadi_mpower__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mpower__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mpower__1" c_casadi_mpower__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_mpower__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_mpower__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mpower__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mpower__2" c_casadi_mpower__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_mpower__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_mpower__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mpower__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mpower__3" c_casadi_mpower__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_mpower__3
-  :: MX -> MX -> IO MX
-casadi_mpower__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mpower__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mrdivide__0" c_casadi_mrdivide__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_mrdivide__0
-  :: SX -> SX -> IO SX
-casadi_mrdivide__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mrdivide__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mrdivide__1" c_casadi_mrdivide__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_mrdivide__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_mrdivide__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mrdivide__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mrdivide__2" c_casadi_mrdivide__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_mrdivide__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_mrdivide__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mrdivide__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mrdivide__3" c_casadi_mrdivide__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_mrdivide__3
-  :: MX -> MX -> IO MX
-casadi_mrdivide__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mrdivide__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__0" c_casadi_mtaylor__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr SX')
-casadi_mtaylor__0
-  :: SX -> SX -> SX -> Int -> Vector Int -> IO SX
-casadi_mtaylor__0 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__1" c_casadi_mtaylor__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_mtaylor__1
-  :: SX -> SX -> SX -> IO SX
-casadi_mtaylor__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__2" c_casadi_mtaylor__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_mtaylor__2
-  :: SX -> SX -> SX -> Int -> IO SX
-casadi_mtaylor__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__3" c_casadi_mtaylor__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr DMatrix')
-casadi_mtaylor__3
-  :: DMatrix -> DMatrix -> DMatrix -> Int -> Vector Int -> IO DMatrix
-casadi_mtaylor__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__4" c_casadi_mtaylor__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_mtaylor__4
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_mtaylor__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__5" c_casadi_mtaylor__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_mtaylor__5
-  :: DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix
-casadi_mtaylor__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__6" c_casadi_mtaylor__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr IMatrix')
-casadi_mtaylor__6
-  :: IMatrix -> IMatrix -> IMatrix -> Int -> Vector Int -> IO IMatrix
-casadi_mtaylor__6 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__6 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__7" c_casadi_mtaylor__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_mtaylor__7
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_mtaylor__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mtaylor__8" c_casadi_mtaylor__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_mtaylor__8
-  :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix
-casadi_mtaylor__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mtaylor__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__0" c_casadi_mul__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-casadi_mul__0
-  :: Vector SX -> IO SX
-casadi_mul__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__1" c_casadi_mul__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_mul__1
-  :: SX -> SX -> IO SX
-casadi_mul__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__2" c_casadi_mul__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-casadi_mul__2
-  :: Vector DMatrix -> IO DMatrix
-casadi_mul__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__3" c_casadi_mul__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_mul__3
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_mul__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__4" c_casadi_mul__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-casadi_mul__4
-  :: Vector IMatrix -> IO IMatrix
-casadi_mul__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__5" c_casadi_mul__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_mul__5
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_mul__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__6" c_casadi_mul__6
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi_mul__6
-  :: Vector MX -> IO MX
-casadi_mul__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__7" c_casadi_mul__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_mul__7
-  :: MX -> MX -> IO MX
-casadi_mul__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__8" c_casadi_mul__8
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-casadi_mul__8
-  :: Vector Sparsity -> IO Sparsity
-casadi_mul__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_mul__9" c_casadi_mul__9
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_mul__9
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi_mul__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_mul__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ne__0" c_casadi_ne__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_ne__0
-  :: SX -> SX -> IO SX
-casadi_ne__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ne__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ne__1" c_casadi_ne__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_ne__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_ne__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ne__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ne__2" c_casadi_ne__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_ne__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_ne__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ne__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ne__3" c_casadi_ne__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_ne__3
-  :: MX -> MX -> IO MX
-casadi_ne__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ne__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_0_mul__0" c_casadi_norm_0_mul__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
-casadi_norm_0_mul__0
-  :: SX -> SX -> IO Int
-casadi_norm_0_mul__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_0_mul__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_0_mul__1" c_casadi_norm_0_mul__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt
-casadi_norm_0_mul__1
-  :: DMatrix -> DMatrix -> IO Int
-casadi_norm_0_mul__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_0_mul__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_0_mul__2" c_casadi_norm_0_mul__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt
-casadi_norm_0_mul__2
-  :: IMatrix -> IMatrix -> IO Int
-casadi_norm_0_mul__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_0_mul__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_0_mul__3" c_casadi_norm_0_mul__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
-casadi_norm_0_mul__3
-  :: MX -> MX -> IO Int
-casadi_norm_0_mul__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_0_mul__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_0_mul__4" c_casadi_norm_0_mul__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
-casadi_norm_0_mul__4
-  :: Sparsity -> Sparsity -> IO Int
-casadi_norm_0_mul__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_0_mul__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_1__0" c_casadi_norm_1__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_norm_1__0
-  :: SX -> IO SX
-casadi_norm_1__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_1__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_1__1" c_casadi_norm_1__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_norm_1__1
-  :: DMatrix -> IO DMatrix
-casadi_norm_1__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_1__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_1__2" c_casadi_norm_1__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_norm_1__2
-  :: IMatrix -> IO IMatrix
-casadi_norm_1__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_1__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_1__3" c_casadi_norm_1__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_norm_1__3
-  :: MX -> IO MX
-casadi_norm_1__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_1__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_2__0" c_casadi_norm_2__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_norm_2__0
-  :: SX -> IO SX
-casadi_norm_2__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_2__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_2__1" c_casadi_norm_2__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_norm_2__1
-  :: DMatrix -> IO DMatrix
-casadi_norm_2__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_2__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_2__2" c_casadi_norm_2__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_norm_2__2
-  :: IMatrix -> IO IMatrix
-casadi_norm_2__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_2__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_2__3" c_casadi_norm_2__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_norm_2__3
-  :: MX -> IO MX
-casadi_norm_2__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_2__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_F__0" c_casadi_norm_F__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_norm_F__0
-  :: SX -> IO SX
-casadi_norm_F__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_F__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_F__1" c_casadi_norm_F__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_norm_F__1
-  :: DMatrix -> IO DMatrix
-casadi_norm_F__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_F__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_F__2" c_casadi_norm_F__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_norm_F__2
-  :: IMatrix -> IO IMatrix
-casadi_norm_F__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_F__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_F__3" c_casadi_norm_F__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_norm_F__3
-  :: MX -> IO MX
-casadi_norm_F__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_F__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_inf__0" c_casadi_norm_inf__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_norm_inf__0
-  :: SX -> IO SX
-casadi_norm_inf__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_inf__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_inf__1" c_casadi_norm_inf__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_norm_inf__1
-  :: DMatrix -> IO DMatrix
-casadi_norm_inf__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_inf__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_inf__2" c_casadi_norm_inf__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_norm_inf__2
-  :: IMatrix -> IO IMatrix
-casadi_norm_inf__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_inf__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_inf__3" c_casadi_norm_inf__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_norm_inf__3
-  :: MX -> IO MX
-casadi_norm_inf__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_inf__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_inf_mul__0" c_casadi_norm_inf_mul__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_norm_inf_mul__0
-  :: SX -> SX -> IO SX
-casadi_norm_inf_mul__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_inf_mul__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_inf_mul__1" c_casadi_norm_inf_mul__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_norm_inf_mul__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_norm_inf_mul__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_inf_mul__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_norm_inf_mul__2" c_casadi_norm_inf_mul__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_norm_inf_mul__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_norm_inf_mul__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_norm_inf_mul__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_not__0" c_casadi_not__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_not__0
-  :: SX -> IO SX
-casadi_not__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_not__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_not__1" c_casadi_not__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_not__1
-  :: DMatrix -> IO DMatrix
-casadi_not__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_not__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_not__2" c_casadi_not__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_not__2
-  :: IMatrix -> IO IMatrix
-casadi_not__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_not__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_not__3" c_casadi_not__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_not__3
-  :: MX -> IO MX
-casadi_not__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_not__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_nullspace__0" c_casadi_nullspace__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_nullspace__0
-  :: SX -> IO SX
-casadi_nullspace__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_nullspace__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_nullspace__1" c_casadi_nullspace__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_nullspace__1
-  :: DMatrix -> IO DMatrix
-casadi_nullspace__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_nullspace__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_nullspace__2" c_casadi_nullspace__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_nullspace__2
-  :: IMatrix -> IO IMatrix
-casadi_nullspace__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_nullspace__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_nullspace__3" c_casadi_nullspace__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_nullspace__3
-  :: MX -> IO MX
-casadi_nullspace__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_nullspace__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__0" c_casadi_offset__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec CInt))
-casadi_offset__0
-  :: Vector SX -> IO (Vector Int)
-casadi_offset__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__1" c_casadi_offset__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec CInt))
-casadi_offset__1
-  :: Vector SX -> Bool -> IO (Vector Int)
-casadi_offset__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__2" c_casadi_offset__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec CInt))
-casadi_offset__2
-  :: Vector DMatrix -> IO (Vector Int)
-casadi_offset__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__3" c_casadi_offset__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO (Ptr (StdVec CInt))
-casadi_offset__3
-  :: Vector DMatrix -> Bool -> IO (Vector Int)
-casadi_offset__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__4" c_casadi_offset__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec CInt))
-casadi_offset__4
-  :: Vector IMatrix -> IO (Vector Int)
-casadi_offset__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__5" c_casadi_offset__5
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> CInt -> IO (Ptr (StdVec CInt))
-casadi_offset__5
-  :: Vector IMatrix -> Bool -> IO (Vector Int)
-casadi_offset__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__6" c_casadi_offset__6
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec CInt))
-casadi_offset__6
-  :: Vector MX -> IO (Vector Int)
-casadi_offset__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__7" c_casadi_offset__7
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec CInt))
-casadi_offset__7
-  :: Vector MX -> Bool -> IO (Vector Int)
-casadi_offset__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__8" c_casadi_offset__8
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec CInt))
-casadi_offset__8
-  :: Vector Sparsity -> IO (Vector Int)
-casadi_offset__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_offset__9" c_casadi_offset__9
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> CInt -> IO (Ptr (StdVec CInt))
-casadi_offset__9
-  :: Vector Sparsity -> Bool -> IO (Vector Int)
-casadi_offset__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_offset__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_or__0" c_casadi_or__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_or__0
-  :: SX -> SX -> IO SX
-casadi_or__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_or__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_or__1" c_casadi_or__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_or__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_or__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_or__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_or__2" c_casadi_or__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_or__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_or__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_or__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_or__3" c_casadi_or__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_or__3
-  :: MX -> MX -> IO MX
-casadi_or__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_or__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_outer_prod__0" c_casadi_outer_prod__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_outer_prod__0
-  :: SX -> SX -> IO SX
-casadi_outer_prod__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_outer_prod__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_outer_prod__1" c_casadi_outer_prod__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_outer_prod__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_outer_prod__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_outer_prod__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_outer_prod__2" c_casadi_outer_prod__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_outer_prod__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_outer_prod__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_outer_prod__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_outer_prod__3" c_casadi_outer_prod__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_outer_prod__3
-  :: MX -> MX -> IO MX
-casadi_outer_prod__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_outer_prod__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__0" c_casadi_pinv__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr StdString -> IO (Ptr SX')
-casadi_pinv__0
-  :: SX -> String -> IO SX
-casadi_pinv__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__1" c_casadi_pinv__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SX')
-casadi_pinv__1
-  :: SX -> String -> M.Map String GenericType -> IO SX
-casadi_pinv__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__2" c_casadi_pinv__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_pinv__2
-  :: SX -> IO SX
-casadi_pinv__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__3" c_casadi_pinv__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')
-casadi_pinv__3
-  :: DMatrix -> String -> IO DMatrix
-casadi_pinv__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__4" c_casadi_pinv__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DMatrix')
-casadi_pinv__4
-  :: DMatrix -> String -> M.Map String GenericType -> IO DMatrix
-casadi_pinv__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__5" c_casadi_pinv__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_pinv__5
-  :: DMatrix -> IO DMatrix
-casadi_pinv__5 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__5 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__6" c_casadi_pinv__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr StdString -> IO (Ptr IMatrix')
-casadi_pinv__6
-  :: IMatrix -> String -> IO IMatrix
-casadi_pinv__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__7" c_casadi_pinv__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr IMatrix')
-casadi_pinv__7
-  :: IMatrix -> String -> M.Map String GenericType -> IO IMatrix
-casadi_pinv__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__8" c_casadi_pinv__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_pinv__8
-  :: IMatrix -> IO IMatrix
-casadi_pinv__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__9" c_casadi_pinv__9
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
-casadi_pinv__9
-  :: MX -> String -> IO MX
-casadi_pinv__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__10" c_casadi_pinv__10
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX')
-casadi_pinv__10
-  :: MX -> String -> M.Map String GenericType -> IO MX
-casadi_pinv__10 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__10 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pinv__11" c_casadi_pinv__11
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_pinv__11
-  :: MX -> IO MX
-casadi_pinv__11 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pinv__11 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_plus__0" c_casadi_plus__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_plus__0
-  :: SX -> SX -> IO SX
-casadi_plus__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_plus__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_plus__1" c_casadi_plus__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_plus__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_plus__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_plus__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_plus__2" c_casadi_plus__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_plus__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_plus__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_plus__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_plus__3" c_casadi_plus__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_plus__3
-  :: MX -> MX -> IO MX
-casadi_plus__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_plus__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_poly_coeff__0" c_casadi_poly_coeff__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_poly_coeff__0
-  :: SX -> SX -> IO SX
-casadi_poly_coeff__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_poly_coeff__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_poly_coeff__1" c_casadi_poly_coeff__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_poly_coeff__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_poly_coeff__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_poly_coeff__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_poly_coeff__2" c_casadi_poly_coeff__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_poly_coeff__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_poly_coeff__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_poly_coeff__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_poly_roots__0" c_casadi_poly_roots__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_poly_roots__0
-  :: SX -> IO SX
-casadi_poly_roots__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_poly_roots__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_poly_roots__1" c_casadi_poly_roots__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_poly_roots__1
-  :: DMatrix -> IO DMatrix
-casadi_poly_roots__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_poly_roots__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_poly_roots__2" c_casadi_poly_roots__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_poly_roots__2
-  :: IMatrix -> IO IMatrix
-casadi_poly_roots__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_poly_roots__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_polyval__0" c_casadi_polyval__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_polyval__0
-  :: SX -> SX -> IO SX
-casadi_polyval__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_polyval__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_polyval__1" c_casadi_polyval__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_polyval__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_polyval__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_polyval__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_polyval__2" c_casadi_polyval__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_polyval__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_polyval__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_polyval__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_polyval__3" c_casadi_polyval__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_polyval__3
-  :: MX -> MX -> IO MX
-casadi_polyval__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_polyval__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_power__0" c_casadi_power__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_power__0
-  :: SX -> SX -> IO SX
-casadi_power__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_power__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_power__1" c_casadi_power__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_power__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_power__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_power__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_power__2" c_casadi_power__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_power__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_power__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_power__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_power__3" c_casadi_power__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_power__3
-  :: MX -> MX -> IO MX
-casadi_power__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_power__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__0" c_casadi_project__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
-casadi_project__0
-  :: SX -> Sparsity -> IO SX
-casadi_project__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__1" c_casadi_project__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> CInt -> IO (Ptr SX')
-casadi_project__1
-  :: SX -> Sparsity -> Bool -> IO SX
-casadi_project__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__2" c_casadi_project__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi_project__2
-  :: DMatrix -> Sparsity -> IO DMatrix
-casadi_project__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__3" c_casadi_project__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr DMatrix')
-casadi_project__3
-  :: DMatrix -> Sparsity -> Bool -> IO DMatrix
-casadi_project__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__4" c_casadi_project__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi_project__4
-  :: IMatrix -> Sparsity -> IO IMatrix
-casadi_project__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__5" c_casadi_project__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix')
-casadi_project__5
-  :: IMatrix -> Sparsity -> Bool -> IO IMatrix
-casadi_project__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__6" c_casadi_project__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
-casadi_project__6
-  :: MX -> Sparsity -> IO MX
-casadi_project__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_project__7" c_casadi_project__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX')
-casadi_project__7
-  :: MX -> Sparsity -> Bool -> IO MX
-casadi_project__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_project__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pw_const__0" c_casadi_pw_const__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_pw_const__0
-  :: SX -> SX -> SX -> IO SX
-casadi_pw_const__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pw_const__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pw_const__1" c_casadi_pw_const__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_pw_const__1
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_pw_const__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pw_const__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pw_const__2" c_casadi_pw_const__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_pw_const__2
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_pw_const__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pw_const__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pw_lin__0" c_casadi_pw_lin__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_pw_lin__0
-  :: SX -> SX -> SX -> IO SX
-casadi_pw_lin__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pw_lin__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pw_lin__1" c_casadi_pw_lin__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_pw_lin__1
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_pw_lin__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pw_lin__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_pw_lin__2" c_casadi_pw_lin__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_pw_lin__2
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_pw_lin__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_pw_lin__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_qr__0" c_casadi_qr__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
-casadi_qr__0
-  :: SX -> SX -> SX -> IO ()
-casadi_qr__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_qr__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_qr__1" c_casadi_qr__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
-casadi_qr__1
-  :: DMatrix -> DMatrix -> DMatrix -> IO ()
-casadi_qr__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_qr__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_qr__2" c_casadi_qr__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
-casadi_qr__2
-  :: IMatrix -> IMatrix -> IMatrix -> IO ()
-casadi_qr__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_qr__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__0" c_casadi_quad_form__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_quad_form__0
-  :: SX -> IO SX
-casadi_quad_form__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__1" c_casadi_quad_form__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_quad_form__1
-  :: SX -> SX -> IO SX
-casadi_quad_form__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__2" c_casadi_quad_form__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_quad_form__2
-  :: DMatrix -> IO DMatrix
-casadi_quad_form__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__3" c_casadi_quad_form__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_quad_form__3
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_quad_form__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__4" c_casadi_quad_form__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_quad_form__4
-  :: IMatrix -> IO IMatrix
-casadi_quad_form__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__5" c_casadi_quad_form__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_quad_form__5
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_quad_form__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__6" c_casadi_quad_form__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_quad_form__6
-  :: MX -> IO MX
-casadi_quad_form__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_quad_form__7" c_casadi_quad_form__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_quad_form__7
-  :: MX -> MX -> IO MX
-casadi_quad_form__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_quad_form__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ramp__0" c_casadi_ramp__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_ramp__0
-  :: SX -> IO SX
-casadi_ramp__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ramp__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ramp__1" c_casadi_ramp__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_ramp__1
-  :: DMatrix -> IO DMatrix
-casadi_ramp__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ramp__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_ramp__2" c_casadi_ramp__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_ramp__2
-  :: IMatrix -> IO IMatrix
-casadi_ramp__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_ramp__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_rdivide__0" c_casadi_rdivide__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_rdivide__0
-  :: SX -> SX -> IO SX
-casadi_rdivide__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_rdivide__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_rdivide__1" c_casadi_rdivide__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_rdivide__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_rdivide__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_rdivide__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_rdivide__2" c_casadi_rdivide__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_rdivide__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_rdivide__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_rdivide__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_rdivide__3" c_casadi_rdivide__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_rdivide__3
-  :: MX -> MX -> IO MX
-casadi_rdivide__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_rdivide__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_rectangle__0" c_casadi_rectangle__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_rectangle__0
-  :: SX -> IO SX
-casadi_rectangle__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_rectangle__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_rectangle__1" c_casadi_rectangle__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_rectangle__1
-  :: DMatrix -> IO DMatrix
-casadi_rectangle__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_rectangle__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_rectangle__2" c_casadi_rectangle__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_rectangle__2
-  :: IMatrix -> IO IMatrix
-casadi_rectangle__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_rectangle__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__0" c_casadi_repmat__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi_repmat__0
-  :: SX -> (Int, Int) -> IO SX
-casadi_repmat__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__1" c_casadi_repmat__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_repmat__1
-  :: SX -> Int -> IO SX
-casadi_repmat__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__2" c_casadi_repmat__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-casadi_repmat__2
-  :: SX -> Int -> Int -> IO SX
-casadi_repmat__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__3" c_casadi_repmat__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi_repmat__3
-  :: DMatrix -> (Int, Int) -> IO DMatrix
-casadi_repmat__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__4" c_casadi_repmat__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_repmat__4
-  :: DMatrix -> Int -> IO DMatrix
-casadi_repmat__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__5" c_casadi_repmat__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi_repmat__5
-  :: DMatrix -> Int -> Int -> IO DMatrix
-casadi_repmat__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__6" c_casadi_repmat__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi_repmat__6
-  :: IMatrix -> (Int, Int) -> IO IMatrix
-casadi_repmat__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__7" c_casadi_repmat__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_repmat__7
-  :: IMatrix -> Int -> IO IMatrix
-casadi_repmat__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__8" c_casadi_repmat__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi_repmat__8
-  :: IMatrix -> Int -> Int -> IO IMatrix
-casadi_repmat__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__9" c_casadi_repmat__9
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi_repmat__9
-  :: MX -> (Int, Int) -> IO MX
-casadi_repmat__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__10" c_casadi_repmat__10
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_repmat__10
-  :: MX -> Int -> IO MX
-casadi_repmat__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__11" c_casadi_repmat__11
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
-casadi_repmat__11
-  :: MX -> Int -> Int -> IO MX
-casadi_repmat__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__12" c_casadi_repmat__12
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
-casadi_repmat__12
-  :: Sparsity -> (Int, Int) -> IO Sparsity
-casadi_repmat__12 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__12 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__13" c_casadi_repmat__13
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi_repmat__13
-  :: Sparsity -> Int -> IO Sparsity
-casadi_repmat__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repmat__14" c_casadi_repmat__14
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi_repmat__14
-  :: Sparsity -> Int -> Int -> IO Sparsity
-casadi_repmat__14 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repmat__14 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__0" c_casadi_repsum__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_repsum__0
-  :: SX -> Int -> IO SX
-casadi_repsum__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__1" c_casadi_repsum__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-casadi_repsum__1
-  :: SX -> Int -> Int -> IO SX
-casadi_repsum__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__2" c_casadi_repsum__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_repsum__2
-  :: DMatrix -> Int -> IO DMatrix
-casadi_repsum__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__3" c_casadi_repsum__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi_repsum__3
-  :: DMatrix -> Int -> Int -> IO DMatrix
-casadi_repsum__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__4" c_casadi_repsum__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_repsum__4
-  :: IMatrix -> Int -> IO IMatrix
-casadi_repsum__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__5" c_casadi_repsum__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi_repsum__5
-  :: IMatrix -> Int -> Int -> IO IMatrix
-casadi_repsum__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__6" c_casadi_repsum__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_repsum__6
-  :: MX -> Int -> IO MX
-casadi_repsum__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_repsum__7" c_casadi_repsum__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
-casadi_repsum__7
-  :: MX -> Int -> Int -> IO MX
-casadi_repsum__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_repsum__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__0" c_casadi_reshape__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
-casadi_reshape__0
-  :: SX -> Sparsity -> IO SX
-casadi_reshape__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__1" c_casadi_reshape__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
-casadi_reshape__1
-  :: SX -> (Int, Int) -> IO SX
-casadi_reshape__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__2" c_casadi_reshape__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-casadi_reshape__2
-  :: SX -> Int -> Int -> IO SX
-casadi_reshape__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__3" c_casadi_reshape__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
-casadi_reshape__3
-  :: DMatrix -> Sparsity -> IO DMatrix
-casadi_reshape__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__4" c_casadi_reshape__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix')
-casadi_reshape__4
-  :: DMatrix -> (Int, Int) -> IO DMatrix
-casadi_reshape__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__5" c_casadi_reshape__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-casadi_reshape__5
-  :: DMatrix -> Int -> Int -> IO DMatrix
-casadi_reshape__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__6" c_casadi_reshape__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
-casadi_reshape__6
-  :: IMatrix -> Sparsity -> IO IMatrix
-casadi_reshape__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__7" c_casadi_reshape__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix')
-casadi_reshape__7
-  :: IMatrix -> (Int, Int) -> IO IMatrix
-casadi_reshape__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__8" c_casadi_reshape__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-casadi_reshape__8
-  :: IMatrix -> Int -> Int -> IO IMatrix
-casadi_reshape__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__9" c_casadi_reshape__9
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
-casadi_reshape__9
-  :: MX -> Sparsity -> IO MX
-casadi_reshape__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__10" c_casadi_reshape__10
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
-casadi_reshape__10
-  :: MX -> (Int, Int) -> IO MX
-casadi_reshape__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__11" c_casadi_reshape__11
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
-casadi_reshape__11
-  :: MX -> Int -> Int -> IO MX
-casadi_reshape__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__12" c_casadi_reshape__12
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_reshape__12
-  :: Sparsity -> Sparsity -> IO Sparsity
-casadi_reshape__12 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__12 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__13" c_casadi_reshape__13
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
-casadi_reshape__13
-  :: Sparsity -> (Int, Int) -> IO Sparsity
-casadi_reshape__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_reshape__14" c_casadi_reshape__14
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
-casadi_reshape__14
-  :: Sparsity -> Int -> Int -> IO Sparsity
-casadi_reshape__14 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_reshape__14 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sign__0" c_casadi_sign__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sign__0
-  :: SX -> IO SX
-casadi_sign__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sign__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sign__1" c_casadi_sign__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sign__1
-  :: DMatrix -> IO DMatrix
-casadi_sign__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sign__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sign__2" c_casadi_sign__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sign__2
-  :: IMatrix -> IO IMatrix
-casadi_sign__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sign__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sign__3" c_casadi_sign__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_sign__3
-  :: MX -> IO MX
-casadi_sign__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sign__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_simplify__0" c_casadi_simplify__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_simplify__0
-  :: SX -> IO SX
-casadi_simplify__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_simplify__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_simplify__1" c_casadi_simplify__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_simplify__1
-  :: DMatrix -> IO DMatrix
-casadi_simplify__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_simplify__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_simplify__2" c_casadi_simplify__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_simplify__2
-  :: IMatrix -> IO IMatrix
-casadi_simplify__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_simplify__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_simplify__3" c_casadi_simplify__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_simplify__3
-  :: MX -> IO MX
-casadi_simplify__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_simplify__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sin__0" c_casadi_sin__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sin__0
-  :: SX -> IO SX
-casadi_sin__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sin__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sin__1" c_casadi_sin__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sin__1
-  :: DMatrix -> IO DMatrix
-casadi_sin__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sin__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sin__2" c_casadi_sin__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sin__2
-  :: IMatrix -> IO IMatrix
-casadi_sin__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sin__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sin__3" c_casadi_sin__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_sin__3
-  :: MX -> IO MX
-casadi_sin__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sin__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sinh__0" c_casadi_sinh__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sinh__0
-  :: SX -> IO SX
-casadi_sinh__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sinh__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sinh__1" c_casadi_sinh__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sinh__1
-  :: DMatrix -> IO DMatrix
-casadi_sinh__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sinh__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sinh__2" c_casadi_sinh__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sinh__2
-  :: IMatrix -> IO IMatrix
-casadi_sinh__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sinh__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sinh__3" c_casadi_sinh__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_sinh__3
-  :: MX -> IO MX
-casadi_sinh__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sinh__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__0" c_casadi_solve__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr StdString -> IO (Ptr SX')
-casadi_solve__0
-  :: SX -> SX -> String -> IO SX
-casadi_solve__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__1" c_casadi_solve__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SX')
-casadi_solve__1
-  :: SX -> SX -> String -> M.Map String GenericType -> IO SX
-casadi_solve__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__2" c_casadi_solve__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_solve__2
-  :: SX -> SX -> IO SX
-casadi_solve__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__3" c_casadi_solve__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')
-casadi_solve__3
-  :: DMatrix -> DMatrix -> String -> IO DMatrix
-casadi_solve__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__4" c_casadi_solve__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DMatrix')
-casadi_solve__4
-  :: DMatrix -> DMatrix -> String -> M.Map String GenericType -> IO DMatrix
-casadi_solve__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__5" c_casadi_solve__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_solve__5
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_solve__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__6" c_casadi_solve__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr StdString -> IO (Ptr IMatrix')
-casadi_solve__6
-  :: IMatrix -> IMatrix -> String -> IO IMatrix
-casadi_solve__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__7" c_casadi_solve__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr IMatrix')
-casadi_solve__7
-  :: IMatrix -> IMatrix -> String -> M.Map String GenericType -> IO IMatrix
-casadi_solve__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__8" c_casadi_solve__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_solve__8
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_solve__8 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__8 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__9" c_casadi_solve__9
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
-casadi_solve__9
-  :: MX -> MX -> String -> IO MX
-casadi_solve__9 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__9 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__10" c_casadi_solve__10
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX')
-casadi_solve__10
-  :: MX -> MX -> String -> M.Map String GenericType -> IO MX
-casadi_solve__10 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__10 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_solve__11" c_casadi_solve__11
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_solve__11
-  :: MX -> MX -> IO MX
-casadi_solve__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_solve__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sparsify__0" c_casadi_sparsify__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sparsify__0
-  :: SX -> IO SX
-casadi_sparsify__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sparsify__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sparsify__1" c_casadi_sparsify__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO (Ptr SX')
-casadi_sparsify__1
-  :: SX -> Double -> IO SX
-casadi_sparsify__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sparsify__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sparsify__2" c_casadi_sparsify__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sparsify__2
-  :: DMatrix -> IO DMatrix
-casadi_sparsify__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sparsify__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sparsify__3" c_casadi_sparsify__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO (Ptr DMatrix')
-casadi_sparsify__3
-  :: DMatrix -> Double -> IO DMatrix
-casadi_sparsify__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sparsify__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sparsify__4" c_casadi_sparsify__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sparsify__4
-  :: IMatrix -> IO IMatrix
-casadi_sparsify__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sparsify__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sparsify__5" c_casadi_sparsify__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO (Ptr IMatrix')
-casadi_sparsify__5
-  :: IMatrix -> Double -> IO IMatrix
-casadi_sparsify__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sparsify__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sprank__0" c_casadi_sprank__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-casadi_sprank__0
-  :: SX -> IO Int
-casadi_sprank__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sprank__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sprank__1" c_casadi_sprank__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-casadi_sprank__1
-  :: DMatrix -> IO Int
-casadi_sprank__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sprank__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sprank__2" c_casadi_sprank__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-casadi_sprank__2
-  :: IMatrix -> IO Int
-casadi_sprank__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sprank__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sprank__3" c_casadi_sprank__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-casadi_sprank__3
-  :: MX -> IO Int
-casadi_sprank__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sprank__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sprank__4" c_casadi_sprank__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-casadi_sprank__4
-  :: Sparsity -> IO Int
-casadi_sprank__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sprank__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sqrt__0" c_casadi_sqrt__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sqrt__0
-  :: SX -> IO SX
-casadi_sqrt__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sqrt__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sqrt__1" c_casadi_sqrt__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sqrt__1
-  :: DMatrix -> IO DMatrix
-casadi_sqrt__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sqrt__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sqrt__2" c_casadi_sqrt__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sqrt__2
-  :: IMatrix -> IO IMatrix
-casadi_sqrt__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sqrt__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sqrt__3" c_casadi_sqrt__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_sqrt__3
-  :: MX -> IO MX
-casadi_sqrt__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sqrt__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__0" c_casadi_substitute__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
-casadi_substitute__0
-  :: Vector SX -> Vector SX -> Vector SX -> IO (Vector SX)
-casadi_substitute__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__1" c_casadi_substitute__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_substitute__1
-  :: SX -> SX -> SX -> IO SX
-casadi_substitute__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__2" c_casadi_substitute__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_substitute__2
-  :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO (Vector DMatrix)
-casadi_substitute__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__3" c_casadi_substitute__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_substitute__3
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_substitute__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__4" c_casadi_substitute__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_substitute__4
-  :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO (Vector IMatrix)
-casadi_substitute__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__5" c_casadi_substitute__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_substitute__5
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_substitute__5 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__5 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__6" c_casadi_substitute__6
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_substitute__6
-  :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
-casadi_substitute__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substitute__7" c_casadi_substitute__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_substitute__7
-  :: MX -> MX -> MX -> IO MX
-casadi_substitute__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substitute__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__0" c_casadi_substituteInPlace__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
-casadi_substituteInPlace__0
-  :: Vector SX -> Vector SX -> Vector SX -> IO ()
-casadi_substituteInPlace__0 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__0 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__1" c_casadi_substituteInPlace__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
-casadi_substituteInPlace__1
-  :: Vector SX -> Vector SX -> Vector SX -> Bool -> IO ()
-casadi_substituteInPlace__1 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__1 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__2" c_casadi_substituteInPlace__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO ()
-casadi_substituteInPlace__2
-  :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO ()
-casadi_substituteInPlace__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__3" c_casadi_substituteInPlace__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO ()
-casadi_substituteInPlace__3
-  :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Bool -> IO ()
-casadi_substituteInPlace__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__4" c_casadi_substituteInPlace__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO ()
-casadi_substituteInPlace__4
-  :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO ()
-casadi_substituteInPlace__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__5" c_casadi_substituteInPlace__5
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> CInt -> IO ()
-casadi_substituteInPlace__5
-  :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Bool -> IO ()
-casadi_substituteInPlace__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__6" c_casadi_substituteInPlace__6
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
-casadi_substituteInPlace__6
-  :: Vector MX -> Vector MX -> Vector MX -> IO ()
-casadi_substituteInPlace__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_substituteInPlace__7" c_casadi_substituteInPlace__7
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO ()
-casadi_substituteInPlace__7
-  :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO ()
-casadi_substituteInPlace__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_substituteInPlace__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumCols__0" c_casadi_sumCols__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sumCols__0
-  :: SX -> IO SX
-casadi_sumCols__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumCols__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumCols__1" c_casadi_sumCols__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sumCols__1
-  :: DMatrix -> IO DMatrix
-casadi_sumCols__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumCols__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumCols__2" c_casadi_sumCols__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sumCols__2
-  :: IMatrix -> IO IMatrix
-casadi_sumCols__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumCols__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumCols__3" c_casadi_sumCols__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_sumCols__3
-  :: MX -> IO MX
-casadi_sumCols__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumCols__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumRows__0" c_casadi_sumRows__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sumRows__0
-  :: SX -> IO SX
-casadi_sumRows__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumRows__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumRows__1" c_casadi_sumRows__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sumRows__1
-  :: DMatrix -> IO DMatrix
-casadi_sumRows__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumRows__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumRows__2" c_casadi_sumRows__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sumRows__2
-  :: IMatrix -> IO IMatrix
-casadi_sumRows__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumRows__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sumRows__3" c_casadi_sumRows__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_sumRows__3
-  :: MX -> IO MX
-casadi_sumRows__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sumRows__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sum_square__0" c_casadi_sum_square__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_sum_square__0
-  :: SX -> IO SX
-casadi_sum_square__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sum_square__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sum_square__1" c_casadi_sum_square__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_sum_square__1
-  :: DMatrix -> IO DMatrix
-casadi_sum_square__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sum_square__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sum_square__2" c_casadi_sum_square__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_sum_square__2
-  :: IMatrix -> IO IMatrix
-casadi_sum_square__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sum_square__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_sum_square__3" c_casadi_sum_square__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_sum_square__3
-  :: MX -> IO MX
-casadi_sum_square__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_sum_square__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_symvar__0" c_casadi_symvar__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
-casadi_symvar__0
-  :: SX -> IO (Vector SX)
-casadi_symvar__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_symvar__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_symvar__1" c_casadi_symvar__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_symvar__1
-  :: DMatrix -> IO (Vector DMatrix)
-casadi_symvar__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_symvar__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_symvar__2" c_casadi_symvar__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_symvar__2
-  :: IMatrix -> IO (Vector IMatrix)
-casadi_symvar__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_symvar__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_symvar__3" c_casadi_symvar__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-casadi_symvar__3
-  :: MX -> IO (Vector MX)
-casadi_symvar__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_symvar__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tan__0" c_casadi_tan__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_tan__0
-  :: SX -> IO SX
-casadi_tan__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tan__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tan__1" c_casadi_tan__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_tan__1
-  :: DMatrix -> IO DMatrix
-casadi_tan__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tan__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tan__2" c_casadi_tan__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_tan__2
-  :: IMatrix -> IO IMatrix
-casadi_tan__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tan__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tan__3" c_casadi_tan__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_tan__3
-  :: MX -> IO MX
-casadi_tan__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tan__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tangent__0" c_casadi_tangent__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_tangent__0
-  :: SX -> SX -> IO SX
-casadi_tangent__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tangent__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tangent__1" c_casadi_tangent__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_tangent__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_tangent__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tangent__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tangent__2" c_casadi_tangent__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_tangent__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_tangent__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tangent__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tangent__3" c_casadi_tangent__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_tangent__3
-  :: MX -> MX -> IO MX
-casadi_tangent__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tangent__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tanh__0" c_casadi_tanh__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_tanh__0
-  :: SX -> IO SX
-casadi_tanh__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tanh__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tanh__1" c_casadi_tanh__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_tanh__1
-  :: DMatrix -> IO DMatrix
-casadi_tanh__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tanh__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tanh__2" c_casadi_tanh__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_tanh__2
-  :: IMatrix -> IO IMatrix
-casadi_tanh__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tanh__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tanh__3" c_casadi_tanh__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_tanh__3
-  :: MX -> IO MX
-casadi_tanh__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tanh__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__0" c_casadi_taylor__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_taylor__0
-  :: SX -> SX -> IO SX
-casadi_taylor__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__1" c_casadi_taylor__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_taylor__1
-  :: SX -> SX -> SX -> IO SX
-casadi_taylor__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__2" c_casadi_taylor__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_taylor__2
-  :: SX -> SX -> SX -> Int -> IO SX
-casadi_taylor__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__3" c_casadi_taylor__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_taylor__3
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_taylor__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__4" c_casadi_taylor__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_taylor__4
-  :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix
-casadi_taylor__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__5" c_casadi_taylor__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_taylor__5
-  :: DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix
-casadi_taylor__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__6" c_casadi_taylor__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_taylor__6
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_taylor__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__7" c_casadi_taylor__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_taylor__7
-  :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix
-casadi_taylor__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_taylor__8" c_casadi_taylor__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_taylor__8
-  :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix
-casadi_taylor__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_taylor__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_times__0" c_casadi_times__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_times__0
-  :: SX -> SX -> IO SX
-casadi_times__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_times__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_times__1" c_casadi_times__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_times__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_times__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_times__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_times__2" c_casadi_times__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_times__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_times__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_times__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_times__3" c_casadi_times__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_times__3
-  :: MX -> MX -> IO MX
-casadi_times__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_times__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_trace__0" c_casadi_trace__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_trace__0
-  :: SX -> IO SX
-casadi_trace__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_trace__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_trace__1" c_casadi_trace__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_trace__1
-  :: DMatrix -> IO DMatrix
-casadi_trace__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_trace__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_trace__2" c_casadi_trace__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_trace__2
-  :: IMatrix -> IO IMatrix
-casadi_trace__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_trace__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_trace__3" c_casadi_trace__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_trace__3
-  :: MX -> IO MX
-casadi_trace__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_trace__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_transpose__0" c_casadi_transpose__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_transpose__0
-  :: SX -> IO SX
-casadi_transpose__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_transpose__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_transpose__1" c_casadi_transpose__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_transpose__1
-  :: DMatrix -> IO DMatrix
-casadi_transpose__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_transpose__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_transpose__2" c_casadi_transpose__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_transpose__2
-  :: IMatrix -> IO IMatrix
-casadi_transpose__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_transpose__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_transpose__3" c_casadi_transpose__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_transpose__3
-  :: MX -> IO MX
-casadi_transpose__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_transpose__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_transpose__4" c_casadi_transpose__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_transpose__4
-  :: Sparsity -> IO Sparsity
-casadi_transpose__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_transpose__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triangle__0" c_casadi_triangle__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_triangle__0
-  :: SX -> IO SX
-casadi_triangle__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triangle__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triangle__1" c_casadi_triangle__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_triangle__1
-  :: DMatrix -> IO DMatrix
-casadi_triangle__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triangle__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triangle__2" c_casadi_triangle__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_triangle__2
-  :: IMatrix -> IO IMatrix
-casadi_triangle__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triangle__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__0" c_casadi_tril__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_tril__0
-  :: SX -> IO SX
-casadi_tril__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__1" c_casadi_tril__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_tril__1
-  :: SX -> Bool -> IO SX
-casadi_tril__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__2" c_casadi_tril__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_tril__2
-  :: DMatrix -> IO DMatrix
-casadi_tril__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__3" c_casadi_tril__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_tril__3
-  :: DMatrix -> Bool -> IO DMatrix
-casadi_tril__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__4" c_casadi_tril__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_tril__4
-  :: IMatrix -> IO IMatrix
-casadi_tril__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__5" c_casadi_tril__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_tril__5
-  :: IMatrix -> Bool -> IO IMatrix
-casadi_tril__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__6" c_casadi_tril__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_tril__6
-  :: MX -> IO MX
-casadi_tril__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__7" c_casadi_tril__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_tril__7
-  :: MX -> Bool -> IO MX
-casadi_tril__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__8" c_casadi_tril__8
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_tril__8
-  :: Sparsity -> IO Sparsity
-casadi_tril__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril__9" c_casadi_tril__9
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi_tril__9
-  :: Sparsity -> Bool -> IO Sparsity
-casadi_tril__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril2symm__0" c_casadi_tril2symm__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_tril2symm__0
-  :: SX -> IO SX
-casadi_tril2symm__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril2symm__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril2symm__1" c_casadi_tril2symm__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_tril2symm__1
-  :: DMatrix -> IO DMatrix
-casadi_tril2symm__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril2symm__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril2symm__2" c_casadi_tril2symm__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_tril2symm__2
-  :: IMatrix -> IO IMatrix
-casadi_tril2symm__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril2symm__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_tril2symm__3" c_casadi_tril2symm__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_tril2symm__3
-  :: MX -> IO MX
-casadi_tril2symm__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_tril2symm__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__0" c_casadi_triu__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_triu__0
-  :: SX -> IO SX
-casadi_triu__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__1" c_casadi_triu__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
-casadi_triu__1
-  :: SX -> Bool -> IO SX
-casadi_triu__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__2" c_casadi_triu__2
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_triu__2
-  :: DMatrix -> IO DMatrix
-casadi_triu__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__3" c_casadi_triu__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-casadi_triu__3
-  :: DMatrix -> Bool -> IO DMatrix
-casadi_triu__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__4" c_casadi_triu__4
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_triu__4
-  :: IMatrix -> IO IMatrix
-casadi_triu__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__5" c_casadi_triu__5
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-casadi_triu__5
-  :: IMatrix -> Bool -> IO IMatrix
-casadi_triu__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__6" c_casadi_triu__6
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_triu__6
-  :: MX -> IO MX
-casadi_triu__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__7" c_casadi_triu__7
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
-casadi_triu__7
-  :: MX -> Bool -> IO MX
-casadi_triu__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__8" c_casadi_triu__8
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_triu__8
-  :: Sparsity -> IO Sparsity
-casadi_triu__8 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__8 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu__9" c_casadi_triu__9
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-casadi_triu__9
-  :: Sparsity -> Bool -> IO Sparsity
-casadi_triu__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu2symm__0" c_casadi_triu2symm__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_triu2symm__0
-  :: SX -> IO SX
-casadi_triu2symm__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu2symm__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu2symm__1" c_casadi_triu2symm__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_triu2symm__1
-  :: DMatrix -> IO DMatrix
-casadi_triu2symm__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu2symm__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu2symm__2" c_casadi_triu2symm__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_triu2symm__2
-  :: IMatrix -> IO IMatrix
-casadi_triu2symm__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu2symm__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_triu2symm__3" c_casadi_triu2symm__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_triu2symm__3
-  :: MX -> IO MX
-casadi_triu2symm__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_triu2symm__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_unite__0" c_casadi_unite__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-casadi_unite__0
-  :: SX -> SX -> IO SX
-casadi_unite__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_unite__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_unite__1" c_casadi_unite__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_unite__1
-  :: DMatrix -> DMatrix -> IO DMatrix
-casadi_unite__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_unite__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_unite__2" c_casadi_unite__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_unite__2
-  :: IMatrix -> IMatrix -> IO IMatrix
-casadi_unite__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_unite__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_unite__3" c_casadi_unite__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-casadi_unite__3
-  :: MX -> MX -> IO MX
-casadi_unite__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_unite__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vec__0" c_casadi_vec__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_vec__0
-  :: SX -> IO SX
-casadi_vec__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vec__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vec__1" c_casadi_vec__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_vec__1
-  :: DMatrix -> IO DMatrix
-casadi_vec__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vec__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vec__2" c_casadi_vec__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_vec__2
-  :: IMatrix -> IO IMatrix
-casadi_vec__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vec__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vec__3" c_casadi_vec__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_vec__3
-  :: MX -> IO MX
-casadi_vec__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vec__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vec__4" c_casadi_vec__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_vec__4
-  :: Sparsity -> IO Sparsity
-casadi_vec__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vec__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vecNZ__0" c_casadi_vecNZ__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-casadi_vecNZ__0
-  :: SX -> IO SX
-casadi_vecNZ__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vecNZ__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vecNZ__1" c_casadi_vecNZ__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-casadi_vecNZ__1
-  :: DMatrix -> IO DMatrix
-casadi_vecNZ__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vecNZ__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vecNZ__2" c_casadi_vecNZ__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-casadi_vecNZ__2
-  :: IMatrix -> IO IMatrix
-casadi_vecNZ__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vecNZ__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vecNZ__3" c_casadi_vecNZ__3
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-casadi_vecNZ__3
-  :: MX -> IO MX
-casadi_vecNZ__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vecNZ__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vecNZ__4" c_casadi_vecNZ__4
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-casadi_vecNZ__4
-  :: Sparsity -> IO Sparsity
-casadi_vecNZ__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vecNZ__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_veccat__0" c_casadi_veccat__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-casadi_veccat__0
-  :: Vector SX -> IO SX
-casadi_veccat__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_veccat__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_veccat__1" c_casadi_veccat__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-casadi_veccat__1
-  :: Vector DMatrix -> IO DMatrix
-casadi_veccat__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_veccat__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_veccat__2" c_casadi_veccat__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-casadi_veccat__2
-  :: Vector IMatrix -> IO IMatrix
-casadi_veccat__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_veccat__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_veccat__3" c_casadi_veccat__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi_veccat__3
-  :: Vector MX -> IO MX
-casadi_veccat__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_veccat__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_veccat__4" c_casadi_veccat__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-casadi_veccat__4
-  :: Vector Sparsity -> IO Sparsity
-casadi_veccat__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_veccat__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertcat__0" c_casadi_vertcat__0
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-casadi_vertcat__0
-  :: Vector SX -> IO SX
-casadi_vertcat__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertcat__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertcat__1" c_casadi_vertcat__1
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-casadi_vertcat__1
-  :: Vector DMatrix -> IO DMatrix
-casadi_vertcat__1 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertcat__1 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertcat__2" c_casadi_vertcat__2
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-casadi_vertcat__2
-  :: Vector IMatrix -> IO IMatrix
-casadi_vertcat__2 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertcat__2 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertcat__3" c_casadi_vertcat__3
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-casadi_vertcat__3
-  :: Vector MX -> IO MX
-casadi_vertcat__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertcat__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertcat__4" c_casadi_vertcat__4
-  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-casadi_vertcat__4
-  :: Vector Sparsity -> IO Sparsity
-casadi_vertcat__4 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertcat__4 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__0" c_casadi_vertsplit__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
-casadi_vertsplit__0
-  :: SX -> IO (Vector SX)
-casadi_vertsplit__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__1" c_casadi_vertsplit__1
-  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-casadi_vertsplit__1
-  :: SX -> Int -> IO (Vector SX)
-casadi_vertsplit__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__2" c_casadi_vertsplit__2
-  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
-casadi_vertsplit__2
-  :: SX -> Vector Int -> IO (Vector SX)
-casadi_vertsplit__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__3" c_casadi_vertsplit__3
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_vertsplit__3
-  :: DMatrix -> IO (Vector DMatrix)
-casadi_vertsplit__3 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__3 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__4" c_casadi_vertsplit__4
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_vertsplit__4
-  :: DMatrix -> Int -> IO (Vector DMatrix)
-casadi_vertsplit__4 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__4 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__5" c_casadi_vertsplit__5
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
-casadi_vertsplit__5
-  :: DMatrix -> Vector Int -> IO (Vector DMatrix)
-casadi_vertsplit__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__6" c_casadi_vertsplit__6
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_vertsplit__6
-  :: IMatrix -> IO (Vector IMatrix)
-casadi_vertsplit__6 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__6 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__7" c_casadi_vertsplit__7
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_vertsplit__7
-  :: IMatrix -> Int -> IO (Vector IMatrix)
-casadi_vertsplit__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__8" c_casadi_vertsplit__8
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
-casadi_vertsplit__8
-  :: IMatrix -> Vector Int -> IO (Vector IMatrix)
-casadi_vertsplit__8 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__8 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__9" c_casadi_vertsplit__9
-  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-casadi_vertsplit__9
-  :: MX -> IO (Vector MX)
-casadi_vertsplit__9 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__9 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__10" c_casadi_vertsplit__10
-  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-casadi_vertsplit__10
-  :: MX -> Int -> IO (Vector MX)
-casadi_vertsplit__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__11" c_casadi_vertsplit__11
-  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
-casadi_vertsplit__11
-  :: MX -> Vector Int -> IO (Vector MX)
-casadi_vertsplit__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__12" c_casadi_vertsplit__12
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_vertsplit__12
-  :: Sparsity -> IO (Vector Sparsity)
-casadi_vertsplit__12 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__12 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__13" c_casadi_vertsplit__13
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_vertsplit__13
-  :: Sparsity -> Int -> IO (Vector Sparsity)
-casadi_vertsplit__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "casadi_vertsplit__14" c_casadi_vertsplit__14
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
-casadi_vertsplit__14
-  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
-casadi_vertsplit__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi_vertsplit__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__0" c_cleIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-cleIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__1" c_cleIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-cleIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__2" c_cleIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-cleIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__3" c_cleIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-cleIn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__4" c_cleIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-cleIn__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__5" c_cleIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-cleIn__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__6" c_cleIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-cleIn__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__7" c_cleIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-cleIn__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__8" c_cleIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-cleIn__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__11" c_cleIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-cleIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__12" c_cleIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-cleIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleIn__13" c_cleIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-cleIn__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-cleIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleOut__0" c_cleOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-cleOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-cleOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleOut__1" c_cleOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-cleOut__1
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-cleOut__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleOut__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleOut__2" c_cleOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-cleOut__2
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-cleOut__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleOut__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "cleOut__5" c_cleOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-cleOut__5
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-cleOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_cleOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "collocationInterpolators" c_collocationInterpolators
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> Ptr (StdVec CDouble) -> IO ()
-collocationInterpolators
-  :: Vector Double -> Vector (Vector Double) -> Vector Double -> IO ()
-collocationInterpolators x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_collocationInterpolators errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "collocationPoints__0" c_collocationPoints__0
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec CDouble))
-collocationPoints__0
-  :: Int -> IO (Vector Double)
-collocationPoints__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_collocationPoints__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "collocationPoints__1" c_collocationPoints__1
-  :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO (Ptr (StdVec CDouble))
-collocationPoints__1
-  :: Int -> String -> IO (Vector Double)
-collocationPoints__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_collocationPoints__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "complement" c_complement
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
-complement
-  :: Vector Int -> Int -> IO (Vector Int)
-complement x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_complement errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__0" c_controldaeIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__1" c_controldaeIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__2" c_controldaeIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__3" c_controldaeIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__4" c_controldaeIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__5" c_controldaeIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__6" c_controldaeIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__7" c_controldaeIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__8" c_controldaeIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__9" c_controldaeIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__10" c_controldaeIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__11" c_controldaeIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__12" c_controldaeIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__13" c_controldaeIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__14" c_controldaeIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__15" c_controldaeIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__15
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__16" c_controldaeIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__16
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controldaeIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__17" c_controldaeIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__17
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__18" c_controldaeIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__18
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__19" c_controldaeIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__19
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__20" c_controldaeIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__21" c_controldaeIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__22" c_controldaeIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__22 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__23" c_controldaeIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__23 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__24" c_controldaeIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__25" c_controldaeIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__26" c_controldaeIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__27" c_controldaeIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__28" c_controldaeIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__29" c_controldaeIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__30" c_controldaeIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__30
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__31" c_controldaeIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__31
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__32" c_controldaeIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__32
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__33" c_controldaeIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__33
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controldaeIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__34" c_controldaeIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__34
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__34 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__34 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__35" c_controldaeIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__35
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__35 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__35 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__36" c_controldaeIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__36
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__36 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__36 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__37" c_controldaeIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__37
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__37 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__37 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__38" c_controldaeIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__38
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__38 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__38 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__39" c_controldaeIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__39
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__39 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__40" c_controldaeIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__40
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__40 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__41" c_controldaeIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__41
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__42" c_controldaeIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__42
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__43" c_controldaeIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__43
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__44" c_controldaeIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__44
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__45" c_controldaeIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__45
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__46" c_controldaeIn__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__46
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__47" c_controldaeIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__47
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__48" c_controldaeIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__48
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__49" c_controldaeIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__49
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controldaeIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__50" c_controldaeIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__50
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controldaeIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__53" c_controldaeIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__53
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__53 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__53 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__54" c_controldaeIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__54
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__54 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__54 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__55" c_controldaeIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__55
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__55 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__55 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__56" c_controldaeIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__56
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__56 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__56 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__57" c_controldaeIn__57
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__57
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__57 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__57 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__58" c_controldaeIn__58
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__58
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__58 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__59" c_controldaeIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__59
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__59 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__60" c_controldaeIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__60
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__61" c_controldaeIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__61
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__62" c_controldaeIn__62
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__62
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__63" c_controldaeIn__63
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__63
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__64" c_controldaeIn__64
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__64
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__65" c_controldaeIn__65
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__65
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__66" c_controldaeIn__66
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__66
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__67" c_controldaeIn__67
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__67
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__68" c_controldaeIn__68
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__68
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controldaeIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controldaeIn__69" c_controldaeIn__69
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controldaeIn__69
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controldaeIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controldaeIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__0" c_controlsimulatorIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controlsimulatorIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__1" c_controlsimulatorIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controlsimulatorIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__2" c_controlsimulatorIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controlsimulatorIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__3" c_controlsimulatorIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-controlsimulatorIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__4" c_controlsimulatorIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-controlsimulatorIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__5" c_controlsimulatorIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__5
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controlsimulatorIn__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__6" c_controlsimulatorIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__6
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controlsimulatorIn__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__7" c_controlsimulatorIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__7
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controlsimulatorIn__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__8" c_controlsimulatorIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__8
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-controlsimulatorIn__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__9" c_controlsimulatorIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__9
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-controlsimulatorIn__9 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__9 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__10" c_controlsimulatorIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__10
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-controlsimulatorIn__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__11" c_controlsimulatorIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__11
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-controlsimulatorIn__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__12" c_controlsimulatorIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__12
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controlsimulatorIn__12 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__12 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__13" c_controlsimulatorIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__13
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-controlsimulatorIn__13 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__13 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__14" c_controlsimulatorIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__14
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-controlsimulatorIn__14 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__14 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__17" c_controlsimulatorIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__17
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-controlsimulatorIn__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__18" c_controlsimulatorIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__18
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-controlsimulatorIn__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__19" c_controlsimulatorIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__19
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controlsimulatorIn__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__20" c_controlsimulatorIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__20
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-controlsimulatorIn__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "controlsimulatorIn__21" c_controlsimulatorIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-controlsimulatorIn__21
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-controlsimulatorIn__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_controlsimulatorIn__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__0" c_daeIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-daeIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__1" c_daeIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-daeIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__2" c_daeIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-daeIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__3" c_daeIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-daeIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__4" c_daeIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-daeIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__5" c_daeIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-daeIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__6" c_daeIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-daeIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__7" c_daeIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__7
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-daeIn__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__8" c_daeIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__8
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-daeIn__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__9" c_daeIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__9
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-daeIn__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__10" c_daeIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__10
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-daeIn__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__11" c_daeIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__11
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-daeIn__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__12" c_daeIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-daeIn__12 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__13" c_daeIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-daeIn__13 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__14" c_daeIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__14
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-daeIn__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__15" c_daeIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__15
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-daeIn__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__16" c_daeIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__16
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-daeIn__16 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__16 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__17" c_daeIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__17
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-daeIn__17 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__17 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__18" c_daeIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__18
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-daeIn__18 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__18 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__19" c_daeIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__19
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-daeIn__19 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__20" c_daeIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__20
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-daeIn__20 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__23" c_daeIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__23
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-daeIn__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__24" c_daeIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__24
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-daeIn__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__25" c_daeIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__25
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-daeIn__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__26" c_daeIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__26
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-daeIn__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__27" c_daeIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__27
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-daeIn__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__28" c_daeIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__28
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-daeIn__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeIn__29" c_daeIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeIn__29
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-daeIn__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__0" c_daeOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-daeOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__1" c_daeOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-daeOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__2" c_daeOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-daeOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__3" c_daeOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-daeOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__4" c_daeOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-daeOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__5" c_daeOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__5
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-daeOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__6" c_daeOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__6
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-daeOut__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__7" c_daeOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__7
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-daeOut__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__8" c_daeOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__8
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-daeOut__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__9" c_daeOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__9
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-daeOut__9 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__9 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__10" c_daeOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__10
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-daeOut__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__11" c_daeOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__11
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-daeOut__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__12" c_daeOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__12
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-daeOut__12 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__12 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__13" c_daeOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__13
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-daeOut__13 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__13 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__14" c_daeOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__14
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-daeOut__14 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__14 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__17" c_daeOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__17
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-daeOut__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__18" c_daeOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__18
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-daeOut__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__19" c_daeOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__19
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-daeOut__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__20" c_daeOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__20
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-daeOut__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "daeOut__21" c_daeOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-daeOut__21
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-daeOut__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_daeOut__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__0" c_dleIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-dleIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__1" c_dleIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-dleIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__2" c_dleIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-dleIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__3" c_dleIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-dleIn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__4" c_dleIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-dleIn__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__5" c_dleIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-dleIn__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__6" c_dleIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-dleIn__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__7" c_dleIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-dleIn__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__8" c_dleIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-dleIn__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__11" c_dleIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-dleIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__12" c_dleIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-dleIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleIn__13" c_dleIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dleIn__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-dleIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleOut__0" c_dleOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dleOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-dleOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleOut__1" c_dleOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dleOut__1
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-dleOut__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleOut__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleOut__2" c_dleOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dleOut__2
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-dleOut__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleOut__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dleOut__5" c_dleOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dleOut__5
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-dleOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dleOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__0" c_dpleIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-dpleIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__1" c_dpleIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-dpleIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__2" c_dpleIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-dpleIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__3" c_dpleIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-dpleIn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__4" c_dpleIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-dpleIn__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__5" c_dpleIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-dpleIn__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__6" c_dpleIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-dpleIn__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__7" c_dpleIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-dpleIn__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__8" c_dpleIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-dpleIn__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__11" c_dpleIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-dpleIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__12" c_dpleIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-dpleIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleIn__13" c_dpleIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleIn__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-dpleIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleOut__0" c_dpleOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-dpleOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-dpleOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleOut__1" c_dpleOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-dpleOut__1
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-dpleOut__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleOut__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleOut__2" c_dpleOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleOut__2
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-dpleOut__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleOut__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dpleOut__5" c_dpleOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-dpleOut__5
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-dpleOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_dpleOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "getSchemeEntryDoc" c_getSchemeEntryDoc
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString)
-getSchemeEntryDoc
-  :: InputOutputScheme -> Int -> IO String
-getSchemeEntryDoc x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_getSchemeEntryDoc errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "getSchemeEntryEnum" c_getSchemeEntryEnum
-  :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO CInt
-getSchemeEntryEnum
-  :: InputOutputScheme -> String -> IO Int
-getSchemeEntryEnum x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_getSchemeEntryEnum errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "getSchemeEntryEnumName" c_getSchemeEntryEnumName
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString)
-getSchemeEntryEnumName
-  :: InputOutputScheme -> Int -> IO String
-getSchemeEntryEnumName x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_getSchemeEntryEnumName errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "getSchemeEntryName" c_getSchemeEntryName
-  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString)
-getSchemeEntryName
-  :: InputOutputScheme -> Int -> IO String
-getSchemeEntryName x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_getSchemeEntryName errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "getSchemeEntryNames" c_getSchemeEntryNames
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
-getSchemeEntryNames
-  :: InputOutputScheme -> IO String
-getSchemeEntryNames x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_getSchemeEntryNames errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "getSchemeName" c_getSchemeName
-  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
-getSchemeName
-  :: InputOutputScheme -> IO String
-getSchemeName x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_getSchemeName errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "getSchemeSize" c_getSchemeSize
-  :: Ptr (Ptr StdString) -> CInt -> IO CInt
-getSchemeSize
-  :: InputOutputScheme -> IO Int
-getSchemeSize x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_getSchemeSize errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__0" c_gradFIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-gradFIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__1" c_gradFIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-gradFIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__2" c_gradFIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-gradFIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__3" c_gradFIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-gradFIn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__4" c_gradFIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-gradFIn__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__5" c_gradFIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-gradFIn__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__6" c_gradFIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-gradFIn__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__7" c_gradFIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-gradFIn__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__8" c_gradFIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-gradFIn__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__11" c_gradFIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-gradFIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__12" c_gradFIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-gradFIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFIn__13" c_gradFIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFIn__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-gradFIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__0" c_gradFOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-gradFOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__1" c_gradFOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-gradFOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__2" c_gradFOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-gradFOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__3" c_gradFOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-gradFOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__4" c_gradFOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-gradFOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__5" c_gradFOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__5
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-gradFOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__6" c_gradFOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__6
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-gradFOut__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__7" c_gradFOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__7
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-gradFOut__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__8" c_gradFOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__8
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-gradFOut__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__9" c_gradFOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__9
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-gradFOut__9 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__9 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__10" c_gradFOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__10
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-gradFOut__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__11" c_gradFOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__11
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-gradFOut__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__12" c_gradFOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__12
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-gradFOut__12 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__12 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__13" c_gradFOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__13
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-gradFOut__13 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__13 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__14" c_gradFOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__14
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-gradFOut__14 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__14 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__17" c_gradFOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__17
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-gradFOut__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__18" c_gradFOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__18
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-gradFOut__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__19" c_gradFOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__19
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-gradFOut__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__20" c_gradFOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__20
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-gradFOut__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "gradFOut__21" c_gradFOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-gradFOut__21
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-gradFOut__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_gradFOut__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__0" c_hessLagIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__1" c_hessLagIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hessLagIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__2" c_hessLagIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__3" c_hessLagIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hessLagIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__4" c_hessLagIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__5" c_hessLagIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hessLagIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__6" c_hessLagIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__7" c_hessLagIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__7
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagIn__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__8" c_hessLagIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__8
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hessLagIn__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__9" c_hessLagIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__9
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagIn__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__10" c_hessLagIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__10
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hessLagIn__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__11" c_hessLagIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__11
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagIn__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__12" c_hessLagIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hessLagIn__12 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__13" c_hessLagIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagIn__13 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__14" c_hessLagIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__14
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-hessLagIn__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__15" c_hessLagIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__15
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-hessLagIn__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__16" c_hessLagIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__16
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hessLagIn__16 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__16 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__17" c_hessLagIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__17
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-hessLagIn__17 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__17 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__18" c_hessLagIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__18
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hessLagIn__18 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__18 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__19" c_hessLagIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__19
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-hessLagIn__19 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__20" c_hessLagIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__20
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hessLagIn__20 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__23" c_hessLagIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__23
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-hessLagIn__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__24" c_hessLagIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__24
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-hessLagIn__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__25" c_hessLagIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__25
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hessLagIn__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__26" c_hessLagIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__26
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-hessLagIn__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__27" c_hessLagIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__27
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hessLagIn__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__28" c_hessLagIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__28
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-hessLagIn__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagIn__29" c_hessLagIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagIn__29
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hessLagIn__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__0" c_hessLagOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__1" c_hessLagOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__2" c_hessLagOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__3" c_hessLagOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__4" c_hessLagOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__5" c_hessLagOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__6" c_hessLagOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__7" c_hessLagOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__8" c_hessLagOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hessLagOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__9" c_hessLagOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__9
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__9 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__9 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__10" c_hessLagOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__10
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__10 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__10 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__11" c_hessLagOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__11
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__11 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__11 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__12" c_hessLagOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__12 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__12 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__13" c_hessLagOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__13 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__13 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__14" c_hessLagOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__14
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__14 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__15" c_hessLagOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__15
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__15 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__16" c_hessLagOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__17" c_hessLagOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hessLagOut__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__18" c_hessLagOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__18
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-hessLagOut__18 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__18 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__19" c_hessLagOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__19
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-hessLagOut__19 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__19 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__20" c_hessLagOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__20
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hessLagOut__20 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__20 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__21" c_hessLagOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__21
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-hessLagOut__21 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__21 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__22" c_hessLagOut__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__22
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hessLagOut__22 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__22 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__23" c_hessLagOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__23
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-hessLagOut__23 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__24" c_hessLagOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__24
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hessLagOut__24 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__25" c_hessLagOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__25
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-hessLagOut__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__26" c_hessLagOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__26
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hessLagOut__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__29" c_hessLagOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__29
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-hessLagOut__29 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__29 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__30" c_hessLagOut__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__30
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-hessLagOut__30 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__30 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__31" c_hessLagOut__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__31
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hessLagOut__31 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__31 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__32" c_hessLagOut__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__32
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-hessLagOut__32 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__32 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__33" c_hessLagOut__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__33
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hessLagOut__33 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__33 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__34" c_hessLagOut__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__34
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-hessLagOut__34 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__35" c_hessLagOut__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__35
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hessLagOut__35 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__36" c_hessLagOut__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__36
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-hessLagOut__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hessLagOut__37" c_hessLagOut__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hessLagOut__37
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hessLagOut__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hessLagOut__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__0" c_hnlpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hnlpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__1" c_hnlpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hnlpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__2" c_hnlpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hnlpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__3" c_hnlpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-hnlpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__4" c_hnlpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-hnlpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__5" c_hnlpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__5
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hnlpIn__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__6" c_hnlpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__6
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hnlpIn__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__7" c_hnlpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__7
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hnlpIn__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__8" c_hnlpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__8
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-hnlpIn__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__9" c_hnlpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__9
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-hnlpIn__9 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__10" c_hnlpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__10
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-hnlpIn__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__11" c_hnlpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__11
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-hnlpIn__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__12" c_hnlpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__12
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hnlpIn__12 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__12 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__13" c_hnlpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__13
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-hnlpIn__13 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__13 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__14" c_hnlpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__14
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-hnlpIn__14 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__17" c_hnlpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__17
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-hnlpIn__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__18" c_hnlpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__18
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-hnlpIn__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__19" c_hnlpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__19
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hnlpIn__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__20" c_hnlpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__20
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-hnlpIn__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "hnlpIn__21" c_hnlpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-hnlpIn__21
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-hnlpIn__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_hnlpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__0" c_integratorIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__1" c_integratorIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__2" c_integratorIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__3" c_integratorIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__4" c_integratorIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__5" c_integratorIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__6" c_integratorIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__7" c_integratorIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__8" c_integratorIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__9" c_integratorIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__10" c_integratorIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__11" c_integratorIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__11
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__12" c_integratorIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__12
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__13" c_integratorIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__13
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__14" c_integratorIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__14
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorIn__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__15" c_integratorIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__15
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorIn__15 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__15 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__16" c_integratorIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorIn__16 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__17" c_integratorIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorIn__17 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__18" c_integratorIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__19" c_integratorIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__20" c_integratorIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__21" c_integratorIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__22" c_integratorIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__22
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-integratorIn__22 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__22 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__23" c_integratorIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__23
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorIn__23 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__23 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__24" c_integratorIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__24
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorIn__24 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__24 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__25" c_integratorIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__25
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorIn__25 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__25 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__26" c_integratorIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__26
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorIn__26 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__26 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__27" c_integratorIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__27
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorIn__27 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__28" c_integratorIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__28
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorIn__28 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__29" c_integratorIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__29
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__30" c_integratorIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__30
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__31" c_integratorIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__32" c_integratorIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__35" c_integratorIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__35
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-integratorIn__35 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__35 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__36" c_integratorIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__36
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorIn__36 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__36 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__37" c_integratorIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__37
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorIn__37 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__37 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__38" c_integratorIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__38
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorIn__38 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__38 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__39" c_integratorIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__39
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorIn__39 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__39 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__40" c_integratorIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__40
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorIn__40 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__41" c_integratorIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__41
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorIn__41 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__42" c_integratorIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__42
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__43" c_integratorIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__43
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__44" c_integratorIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__44
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorIn__45" c_integratorIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorIn__45
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__0" c_integratorOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__1" c_integratorOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__2" c_integratorOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__3" c_integratorOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__4" c_integratorOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__5" c_integratorOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__6" c_integratorOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__7" c_integratorOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__8" c_integratorOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__9" c_integratorOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-integratorOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__10" c_integratorOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-integratorOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__11" c_integratorOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__11
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorOut__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__12" c_integratorOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__12
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorOut__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__13" c_integratorOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__13
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorOut__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__14" c_integratorOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__14
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorOut__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__15" c_integratorOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__15
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorOut__15 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__15 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__16" c_integratorOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorOut__16 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__17" c_integratorOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorOut__17 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__18" c_integratorOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorOut__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__19" c_integratorOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorOut__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__20" c_integratorOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-integratorOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__21" c_integratorOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-integratorOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__22" c_integratorOut__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__22
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-integratorOut__22 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__22 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__23" c_integratorOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__23
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorOut__23 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__23 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__24" c_integratorOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__24
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorOut__24 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__24 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__25" c_integratorOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__25
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorOut__25 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__25 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__26" c_integratorOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__26
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorOut__26 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__26 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__27" c_integratorOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__27
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorOut__27 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__28" c_integratorOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__28
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorOut__28 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__29" c_integratorOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__29
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorOut__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__30" c_integratorOut__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__30
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorOut__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__31" c_integratorOut__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-integratorOut__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__32" c_integratorOut__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-integratorOut__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__35" c_integratorOut__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__35
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-integratorOut__35 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__35 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__36" c_integratorOut__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__36
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorOut__36 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__36 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__37" c_integratorOut__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__37
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorOut__37 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__37 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__38" c_integratorOut__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__38
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorOut__38 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__38 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__39" c_integratorOut__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__39
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorOut__39 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__39 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__40" c_integratorOut__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__40
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorOut__40 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__41" c_integratorOut__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__41
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorOut__41 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__42" c_integratorOut__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__42
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorOut__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__43" c_integratorOut__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__43
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorOut__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__44" c_integratorOut__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__44
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-integratorOut__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "integratorOut__45" c_integratorOut__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-integratorOut__45
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-integratorOut__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_integratorOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__0" c_jacGIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-jacGIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__1" c_jacGIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-jacGIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__2" c_jacGIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-jacGIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__3" c_jacGIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-jacGIn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__4" c_jacGIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-jacGIn__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__5" c_jacGIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-jacGIn__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__6" c_jacGIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-jacGIn__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__7" c_jacGIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-jacGIn__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__8" c_jacGIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-jacGIn__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__11" c_jacGIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-jacGIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__12" c_jacGIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-jacGIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGIn__13" c_jacGIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGIn__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-jacGIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__0" c_jacGOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-jacGOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__1" c_jacGOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-jacGOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__2" c_jacGOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-jacGOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__3" c_jacGOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-jacGOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__4" c_jacGOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-jacGOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__5" c_jacGOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__5
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-jacGOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__6" c_jacGOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__6
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-jacGOut__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__7" c_jacGOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__7
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-jacGOut__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__8" c_jacGOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__8
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-jacGOut__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__9" c_jacGOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__9
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-jacGOut__9 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__9 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__10" c_jacGOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__10
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-jacGOut__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__11" c_jacGOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__11
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-jacGOut__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__12" c_jacGOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__12
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-jacGOut__12 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__12 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__13" c_jacGOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__13
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-jacGOut__13 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__13 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__14" c_jacGOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__14
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-jacGOut__14 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__14 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__17" c_jacGOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__17
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-jacGOut__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__18" c_jacGOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__18
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-jacGOut__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__19" c_jacGOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__19
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-jacGOut__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__20" c_jacGOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__20
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-jacGOut__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "jacGOut__21" c_jacGOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-jacGOut__21
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-jacGOut__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_jacGOut__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__0" c_linsolIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-linsolIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__1" c_linsolIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-linsolIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__2" c_linsolIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-linsolIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__3" c_linsolIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-linsolIn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__4" c_linsolIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-linsolIn__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__5" c_linsolIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-linsolIn__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__6" c_linsolIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-linsolIn__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__7" c_linsolIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-linsolIn__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__8" c_linsolIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-linsolIn__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__11" c_linsolIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-linsolIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__12" c_linsolIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-linsolIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolIn__13" c_linsolIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolIn__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-linsolIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolOut__0" c_linsolOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-linsolOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-linsolOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolOut__1" c_linsolOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-linsolOut__1
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-linsolOut__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolOut__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolOut__2" c_linsolOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolOut__2
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-linsolOut__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolOut__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "linsolOut__5" c_linsolOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-linsolOut__5
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-linsolOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_linsolOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lookupvector" c_lookupvector
-  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
-lookupvector
-  :: Vector Int -> Int -> IO (Vector Int)
-lookupvector x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lookupvector errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__0" c_lpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__1" c_lpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__2" c_lpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__3" c_lpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__4" c_lpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__5" c_lpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__6" c_lpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__7" c_lpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__8" c_lpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__9" c_lpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__10" c_lpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__11" c_lpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__11
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__12" c_lpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__12
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__13" c_lpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__13
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__14" c_lpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__14
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpIn__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__15" c_lpIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__15
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpIn__15 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__16" c_lpIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpIn__16 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__17" c_lpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__18" c_lpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__19" c_lpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__20" c_lpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__21" c_lpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__22" c_lpIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__22
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-lpIn__22 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__22 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__23" c_lpIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__23
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpIn__23 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__23 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__24" c_lpIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__24
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpIn__24 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__24 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__25" c_lpIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__25
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpIn__25 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__25 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__26" c_lpIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__26
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpIn__26 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__27" c_lpIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__27
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpIn__27 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__28" c_lpIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__28
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__29" c_lpIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__29
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__30" c_lpIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__30
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__31" c_lpIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__32" c_lpIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__35" c_lpIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__35
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-lpIn__35 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__35 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__36" c_lpIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__36
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpIn__36 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__36 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__37" c_lpIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__37
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpIn__37 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__37 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__38" c_lpIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__38
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpIn__38 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__38 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__39" c_lpIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__39
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpIn__39 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__40" c_lpIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__40
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpIn__40 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__41" c_lpIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__41
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__42" c_lpIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__42
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__43" c_lpIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__43
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__44" c_lpIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__44
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpIn__45" c_lpIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpIn__45
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__0" c_lpOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__1" c_lpOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__2" c_lpOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__3" c_lpOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__4" c_lpOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__5" c_lpOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lpOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__6" c_lpOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__7" c_lpOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__7
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpOut__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__8" c_lpOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__8
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpOut__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__9" c_lpOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__9
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpOut__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__10" c_lpOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__10
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpOut__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__11" c_lpOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__11
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpOut__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__12" c_lpOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lpOut__12 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__13" c_lpOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lpOut__13 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__14" c_lpOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__14
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-lpOut__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__15" c_lpOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__15
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpOut__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__16" c_lpOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__16
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpOut__16 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__16 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__17" c_lpOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__17
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpOut__17 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__17 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__18" c_lpOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__18
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpOut__18 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__19" c_lpOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__19
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lpOut__19 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__20" c_lpOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__20
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__23" c_lpOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__23
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-lpOut__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__24" c_lpOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__24
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpOut__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__25" c_lpOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__25
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpOut__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__26" c_lpOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__26
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpOut__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__27" c_lpOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__27
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpOut__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__28" c_lpOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__28
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lpOut__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lpOut__29" c_lpOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lpOut__29
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__0" c_lrdleIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdleIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__1" c_lrdleIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lrdleIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__2" c_lrdleIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdleIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__3" c_lrdleIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lrdleIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__4" c_lrdleIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdleIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__5" c_lrdleIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lrdleIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__6" c_lrdleIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdleIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__7" c_lrdleIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__7
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdleIn__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__8" c_lrdleIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__8
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lrdleIn__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__9" c_lrdleIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__9
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdleIn__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__10" c_lrdleIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__10
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lrdleIn__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__11" c_lrdleIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__11
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdleIn__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__12" c_lrdleIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lrdleIn__12 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__13" c_lrdleIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdleIn__13 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__14" c_lrdleIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__14
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-lrdleIn__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__15" c_lrdleIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__15
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-lrdleIn__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__16" c_lrdleIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__16
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lrdleIn__16 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__16 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__17" c_lrdleIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__17
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lrdleIn__17 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__17 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__18" c_lrdleIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__18
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lrdleIn__18 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__18 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__19" c_lrdleIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__19
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lrdleIn__19 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__20" c_lrdleIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__20
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lrdleIn__20 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__23" c_lrdleIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__23
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-lrdleIn__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__24" c_lrdleIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__24
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-lrdleIn__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__25" c_lrdleIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__25
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lrdleIn__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__26" c_lrdleIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__26
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lrdleIn__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__27" c_lrdleIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__27
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lrdleIn__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__28" c_lrdleIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__28
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lrdleIn__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleIn__29" c_lrdleIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleIn__29
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lrdleIn__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleOut__0" c_lrdleOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdleOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleOut__1" c_lrdleOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleOut__1
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdleOut__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleOut__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleOut__2" c_lrdleOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleOut__2
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-lrdleOut__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleOut__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdleOut__5" c_lrdleOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdleOut__5
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-lrdleOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdleOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__0" c_lrdpleIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdpleIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__1" c_lrdpleIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lrdpleIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__2" c_lrdpleIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdpleIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__3" c_lrdpleIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lrdpleIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__4" c_lrdpleIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdpleIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__5" c_lrdpleIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-lrdpleIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__6" c_lrdpleIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdpleIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__7" c_lrdpleIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__7
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdpleIn__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__8" c_lrdpleIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__8
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lrdpleIn__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__9" c_lrdpleIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__9
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdpleIn__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__10" c_lrdpleIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__10
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lrdpleIn__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__11" c_lrdpleIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__11
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdpleIn__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__12" c_lrdpleIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-lrdpleIn__12 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__13" c_lrdpleIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdpleIn__13 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__14" c_lrdpleIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__14
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-lrdpleIn__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__15" c_lrdpleIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__15
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-lrdpleIn__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__16" c_lrdpleIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__16
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lrdpleIn__16 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__16 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__17" c_lrdpleIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__17
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lrdpleIn__17 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__17 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__18" c_lrdpleIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__18
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lrdpleIn__18 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__18 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__19" c_lrdpleIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__19
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-lrdpleIn__19 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__20" c_lrdpleIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__20
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-lrdpleIn__20 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__23" c_lrdpleIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__23
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-lrdpleIn__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__24" c_lrdpleIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__24
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-lrdpleIn__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__25" c_lrdpleIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__25
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lrdpleIn__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__26" c_lrdpleIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__26
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lrdpleIn__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__27" c_lrdpleIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__27
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lrdpleIn__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__28" c_lrdpleIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__28
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-lrdpleIn__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleIn__29" c_lrdpleIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleIn__29
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-lrdpleIn__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleOut__0" c_lrdpleOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-lrdpleOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleOut__1" c_lrdpleOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleOut__1
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-lrdpleOut__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleOut__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleOut__2" c_lrdpleOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleOut__2
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-lrdpleOut__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleOut__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "lrdpleOut__5" c_lrdpleOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-lrdpleOut__5
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-lrdpleOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_lrdpleOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__0" c_nlpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__1" c_nlpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__2" c_nlpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__3" c_nlpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpIn__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__4" c_nlpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpIn__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__5" c_nlpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpIn__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__6" c_nlpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-nlpIn__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__7" c_nlpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpIn__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__8" c_nlpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpIn__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__11" c_nlpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-nlpIn__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__12" c_nlpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpIn__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpIn__13" c_nlpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpIn__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpIn__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpIn__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__0" c_nlpOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__1" c_nlpOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__2" c_nlpOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__3" c_nlpOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__3
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpOut__3 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__3 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__4" c_nlpOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__4
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpOut__4 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__4 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__5" c_nlpOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__5
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpOut__5 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__5 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__6" c_nlpOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__6
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-nlpOut__6 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__6 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__7" c_nlpOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__7
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpOut__7 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__7 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__8" c_nlpOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__8
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpOut__8 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__8 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__11" c_nlpOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__11
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-nlpOut__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__12" c_nlpOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__12
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpOut__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpOut__13" c_nlpOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpOut__13
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpOut__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpOut__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__0" c_nlpSolverIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__1" c_nlpSolverIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__2" c_nlpSolverIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__3" c_nlpSolverIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__4" c_nlpSolverIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__5" c_nlpSolverIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__6" c_nlpSolverIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__7" c_nlpSolverIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__8" c_nlpSolverIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__9" c_nlpSolverIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__10" c_nlpSolverIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__11" c_nlpSolverIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__12" c_nlpSolverIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__13" c_nlpSolverIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__14" c_nlpSolverIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__15" c_nlpSolverIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__15
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__15 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__15 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__16" c_nlpSolverIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__16
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__16 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__16 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__17" c_nlpSolverIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__17
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__17 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__17 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__18" c_nlpSolverIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__18 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__18 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__19" c_nlpSolverIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__19 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__19 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__20" c_nlpSolverIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__20 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__21" c_nlpSolverIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__21 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__22" c_nlpSolverIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__23" c_nlpSolverIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__24" c_nlpSolverIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__25" c_nlpSolverIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__26" c_nlpSolverIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__27" c_nlpSolverIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__28" c_nlpSolverIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__29" c_nlpSolverIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__30" c_nlpSolverIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__30
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__30 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__30 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__31" c_nlpSolverIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__31
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverIn__31 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__31 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__32" c_nlpSolverIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__32
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__32 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__32 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__33" c_nlpSolverIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__33
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverIn__33 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__33 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__34" c_nlpSolverIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__34
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__34 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__34 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__35" c_nlpSolverIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__35
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverIn__35 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__36" c_nlpSolverIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__36
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__36 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__37" c_nlpSolverIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__37
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__38" c_nlpSolverIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__38
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__39" c_nlpSolverIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__39
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__40" c_nlpSolverIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__40
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__41" c_nlpSolverIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__41
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__42" c_nlpSolverIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__42
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__43" c_nlpSolverIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__43
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__44" c_nlpSolverIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__44
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__47" c_nlpSolverIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__47
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__47 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__47 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__48" c_nlpSolverIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__48
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverIn__48 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__48 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__49" c_nlpSolverIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__49
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__49 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__49 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__50" c_nlpSolverIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__50
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverIn__50 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__50 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__51" c_nlpSolverIn__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__51
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__51 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__51 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__52" c_nlpSolverIn__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__52
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverIn__52 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__53" c_nlpSolverIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__53
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__53 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__54" c_nlpSolverIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__54
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__55" c_nlpSolverIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__55
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__56" c_nlpSolverIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__56
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__57" c_nlpSolverIn__57
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__57
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__58" c_nlpSolverIn__58
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__58
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__59" c_nlpSolverIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__59
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__60" c_nlpSolverIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__60
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverIn__61" c_nlpSolverIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverIn__61
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__0" c_nlpSolverOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__1" c_nlpSolverOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__2" c_nlpSolverOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__3" c_nlpSolverOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__4" c_nlpSolverOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__5" c_nlpSolverOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__6" c_nlpSolverOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__7" c_nlpSolverOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__8" c_nlpSolverOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__9" c_nlpSolverOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__10" c_nlpSolverOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-nlpSolverOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__11" c_nlpSolverOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__11
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__12" c_nlpSolverOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__12
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__13" c_nlpSolverOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__13
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__14" c_nlpSolverOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__14
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__15" c_nlpSolverOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__15
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__15 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__15 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__16" c_nlpSolverOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__16 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__17" c_nlpSolverOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__17 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__18" c_nlpSolverOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__19" c_nlpSolverOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__20" c_nlpSolverOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__21" c_nlpSolverOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-nlpSolverOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__22" c_nlpSolverOut__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__22
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverOut__22 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__22 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__23" c_nlpSolverOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__23
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverOut__23 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__23 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__24" c_nlpSolverOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__24
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverOut__24 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__24 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__25" c_nlpSolverOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__25
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverOut__25 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__25 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__26" c_nlpSolverOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__26
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverOut__26 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__26 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__27" c_nlpSolverOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__27
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverOut__27 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__28" c_nlpSolverOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__28
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverOut__28 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__29" c_nlpSolverOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__29
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverOut__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__30" c_nlpSolverOut__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__30
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverOut__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__31" c_nlpSolverOut__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-nlpSolverOut__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__32" c_nlpSolverOut__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-nlpSolverOut__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__35" c_nlpSolverOut__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__35
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverOut__35 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__35 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__36" c_nlpSolverOut__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__36
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverOut__36 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__36 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__37" c_nlpSolverOut__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__37
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverOut__37 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__37 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__38" c_nlpSolverOut__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__38
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverOut__38 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__38 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__39" c_nlpSolverOut__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__39
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverOut__39 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__39 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__40" c_nlpSolverOut__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__40
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverOut__40 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__41" c_nlpSolverOut__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__41
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverOut__41 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__42" c_nlpSolverOut__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__42
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverOut__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__43" c_nlpSolverOut__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__43
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverOut__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__44" c_nlpSolverOut__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__44
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-nlpSolverOut__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nlpSolverOut__45" c_nlpSolverOut__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-nlpSolverOut__45
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-nlpSolverOut__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_nlpSolverOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__0" c_qcqpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__1" c_qcqpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__2" c_qcqpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__3" c_qcqpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__4" c_qcqpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__5" c_qcqpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__6" c_qcqpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__7" c_qcqpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__8" c_qcqpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__9" c_qcqpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__10" c_qcqpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__11" c_qcqpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__12" c_qcqpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__13" c_qcqpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__14" c_qcqpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__15" c_qcqpIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__15
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__16" c_qcqpIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__16
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__17" c_qcqpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__17
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__18" c_qcqpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__18
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__19" c_qcqpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__19
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__20" c_qcqpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__20
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__21" c_qcqpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__21
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__22" c_qcqpIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__22
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__23" c_qcqpIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__23
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__24" c_qcqpIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__24
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__25" c_qcqpIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__25
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__26" c_qcqpIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__27" c_qcqpIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__28" c_qcqpIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__29" c_qcqpIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__30" c_qcqpIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__30
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__31" c_qcqpIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__31
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__32" c_qcqpIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__32
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__33" c_qcqpIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__33
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__34" c_qcqpIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__34
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__35" c_qcqpIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__35
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__36" c_qcqpIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__36
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__37" c_qcqpIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__37
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__38" c_qcqpIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__38
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__39" c_qcqpIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__39
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__40" c_qcqpIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__40
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__41" c_qcqpIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__41
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__42" c_qcqpIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__42
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__43" c_qcqpIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__43
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__44" c_qcqpIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__44
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__45" c_qcqpIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__45
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__46" c_qcqpIn__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__46
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__46 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__46 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__47" c_qcqpIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__47
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__47 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__47 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__48" c_qcqpIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__48
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__48 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__48 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__49" c_qcqpIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__49
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__49 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__49 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__50" c_qcqpIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__50
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__50 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__51" c_qcqpIn__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__51
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__51 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__52" c_qcqpIn__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__52
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__52 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__53" c_qcqpIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__53
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__54" c_qcqpIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__54
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__55" c_qcqpIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__55
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__56" c_qcqpIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__56
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__57" c_qcqpIn__57
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__57
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__58" c_qcqpIn__58
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__58
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__59" c_qcqpIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__59
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__60" c_qcqpIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__60
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__61" c_qcqpIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__61
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__62" c_qcqpIn__62
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__62
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__63" c_qcqpIn__63
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__63
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__64" c_qcqpIn__64
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__64
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__65" c_qcqpIn__65
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__65
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__66" c_qcqpIn__66
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__66
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__67" c_qcqpIn__67
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__67
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__68" c_qcqpIn__68
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__68
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__71" c_qcqpIn__71
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__71
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__71 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__71 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__72" c_qcqpIn__72
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__72
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__72 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__72 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__73" c_qcqpIn__73
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__73
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__73 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__73 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__74" c_qcqpIn__74
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__74
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__74 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__74 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__75" c_qcqpIn__75
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__75
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__75 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__75 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__76" c_qcqpIn__76
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__76
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__76 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__76 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__77" c_qcqpIn__77
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__77
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__77 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__77 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__78" c_qcqpIn__78
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__78
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__78 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__78 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__79" c_qcqpIn__79
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__79
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__79 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__79 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__80" c_qcqpIn__80
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__80
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__80 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__80 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__81" c_qcqpIn__81
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__81
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__81 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__81 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__82" c_qcqpIn__82
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__82
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__82 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__82 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__83" c_qcqpIn__83
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__83
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__83 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__83 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__84" c_qcqpIn__84
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__84
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__84 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__84 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__85" c_qcqpIn__85
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__85
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__85 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__85 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__86" c_qcqpIn__86
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__86
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__86 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__86 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__87" c_qcqpIn__87
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__87
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__87 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__87 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__88" c_qcqpIn__88
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__88
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__88 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__88 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__89" c_qcqpIn__89
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__89
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__89 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__89 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__90" c_qcqpIn__90
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__90
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__90 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__90 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__91" c_qcqpIn__91
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__91
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__91 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__91 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__92" c_qcqpIn__92
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__92
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpIn__92 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__92 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpIn__93" c_qcqpIn__93
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpIn__93
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpIn__93 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpIn__93 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__0" c_qcqpOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__1" c_qcqpOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__2" c_qcqpOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__3" c_qcqpOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__4" c_qcqpOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__5" c_qcqpOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qcqpOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__6" c_qcqpOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qcqpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__7" c_qcqpOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__7
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpOut__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__8" c_qcqpOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__8
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpOut__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__9" c_qcqpOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__9
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpOut__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__10" c_qcqpOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__10
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpOut__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__11" c_qcqpOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__11
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpOut__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__12" c_qcqpOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qcqpOut__12 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__13" c_qcqpOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qcqpOut__13 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__14" c_qcqpOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__14
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-qcqpOut__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__15" c_qcqpOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__15
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpOut__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__16" c_qcqpOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__16
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpOut__16 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__16 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__17" c_qcqpOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__17
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpOut__17 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__17 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__18" c_qcqpOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__18
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpOut__18 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__19" c_qcqpOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__19
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qcqpOut__19 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__20" c_qcqpOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__20
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qcqpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__23" c_qcqpOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__23
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-qcqpOut__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__24" c_qcqpOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__24
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpOut__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__25" c_qcqpOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__25
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpOut__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__26" c_qcqpOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__26
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpOut__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__27" c_qcqpOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__27
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpOut__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__28" c_qcqpOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__28
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qcqpOut__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qcqpOut__29" c_qcqpOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qcqpOut__29
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qcqpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qcqpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__0" c_qpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__1" c_qpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__2" c_qpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__3" c_qpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__4" c_qpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__5" c_qpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__6" c_qpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__7" c_qpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__8" c_qpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__9" c_qpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__10" c_qpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__11" c_qpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__12" c_qpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__13" c_qpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__14" c_qpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__15" c_qpIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__15
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__16" c_qpIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__16
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__17" c_qpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__17
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__18" c_qpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__18
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__19" c_qpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__19
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__20" c_qpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__21" c_qpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__22" c_qpIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__22 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__23" c_qpIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__24" c_qpIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__25" c_qpIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__26" c_qpIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__27" c_qpIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__28" c_qpIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__29" c_qpIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__30" c_qpIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__30
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__31" c_qpIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__31
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__32" c_qpIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__32
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__33" c_qpIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__33
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__34" c_qpIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__34
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__34 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__34 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__35" c_qpIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__35
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__35 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__35 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__36" c_qpIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__36
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__36 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__36 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__37" c_qpIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__37
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__37 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__37 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__38" c_qpIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__38
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__38 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__39" c_qpIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__39
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__39 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__40" c_qpIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__40
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__41" c_qpIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__41
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__42" c_qpIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__42
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__43" c_qpIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__43
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__44" c_qpIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__44
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__45" c_qpIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__45
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__46" c_qpIn__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__46
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__47" c_qpIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__47
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__48" c_qpIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__48
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__49" c_qpIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__49
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__50" c_qpIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__50
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__53" c_qpIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__53
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__53 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__53 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__54" c_qpIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__54
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__54 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__54 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__55" c_qpIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__55
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__55 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__55 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__56" c_qpIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__56
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__56 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__56 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__57" c_qpIn__57
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__57
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__57 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__58" c_qpIn__58
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__58
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__58 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__59" c_qpIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__59
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__60" c_qpIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__60
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__61" c_qpIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__61
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__62" c_qpIn__62
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__62
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__63" c_qpIn__63
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__63
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__64" c_qpIn__64
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__64
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__65" c_qpIn__65
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__65
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__66" c_qpIn__66
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__66
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__67" c_qpIn__67
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__67
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__68" c_qpIn__68
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__68
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpIn__69" c_qpIn__69
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpIn__69
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__0" c_qpOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__1" c_qpOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__2" c_qpOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__3" c_qpOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__4" c_qpOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__5" c_qpOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-qpOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__6" c_qpOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-qpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__7" c_qpOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__7
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpOut__7 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__7 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__8" c_qpOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__8
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpOut__8 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__8 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__9" c_qpOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__9
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpOut__9 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__9 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__10" c_qpOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__10
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpOut__10 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__10 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__11" c_qpOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__11
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpOut__11 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__12" c_qpOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__12
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-qpOut__12 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__13" c_qpOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__13
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-qpOut__13 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__14" c_qpOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__14
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-qpOut__14 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__14 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__15" c_qpOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__15
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpOut__15 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__15 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__16" c_qpOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__16
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpOut__16 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__16 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__17" c_qpOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__17
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpOut__17 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__17 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__18" c_qpOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__18
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpOut__18 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__19" c_qpOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__19
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-qpOut__19 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__20" c_qpOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__20
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-qpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__23" c_qpOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__23
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-qpOut__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__24" c_qpOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__24
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpOut__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__25" c_qpOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__25
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpOut__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__26" c_qpOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__26
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpOut__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__27" c_qpOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__27
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpOut__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__28" c_qpOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__28
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-qpOut__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "qpOut__29" c_qpOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-qpOut__29
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-qpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_qpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__0" c_rdaeIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__1" c_rdaeIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__2" c_rdaeIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__3" c_rdaeIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__4" c_rdaeIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__5" c_rdaeIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__6" c_rdaeIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__7" c_rdaeIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__8" c_rdaeIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__9" c_rdaeIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__10" c_rdaeIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__11" c_rdaeIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__12" c_rdaeIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__13" c_rdaeIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__13
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__14" c_rdaeIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__14
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__14 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__14 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__15" c_rdaeIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__15
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__15 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__15 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__16" c_rdaeIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__16 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__16 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__17" c_rdaeIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__17 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__17 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__18" c_rdaeIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__18 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__19" c_rdaeIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__19 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__20" c_rdaeIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__21" c_rdaeIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__22" c_rdaeIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__23" c_rdaeIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__24" c_rdaeIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__25" c_rdaeIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__26" c_rdaeIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__26
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-rdaeIn__26 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__26 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__27" c_rdaeIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__27
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeIn__27 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__27 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__28" c_rdaeIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__28
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeIn__28 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__28 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__29" c_rdaeIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__29
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeIn__29 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__29 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__30" c_rdaeIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__30
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeIn__30 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__30 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__31" c_rdaeIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeIn__31 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__32" c_rdaeIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeIn__32 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__33" c_rdaeIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__33
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__34" c_rdaeIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__34
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__35" c_rdaeIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__35
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__36" c_rdaeIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__36
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__37" c_rdaeIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__37
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__38" c_rdaeIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__38
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__41" c_rdaeIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__41
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-rdaeIn__41 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__41 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__42" c_rdaeIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__42
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeIn__42 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__42 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__43" c_rdaeIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__43
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeIn__43 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__43 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__44" c_rdaeIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__44
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeIn__44 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__44 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__45" c_rdaeIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__45
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeIn__45 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__45 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__46" c_rdaeIn__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__46
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeIn__46 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__47" c_rdaeIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__47
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeIn__47 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__48" c_rdaeIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__48
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__49" c_rdaeIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__49
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__50" c_rdaeIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__50
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__51" c_rdaeIn__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__51
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeIn__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__52" c_rdaeIn__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__52
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeIn__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeIn__53" c_rdaeIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeIn__53
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__0" c_rdaeOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__1" c_rdaeOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__2" c_rdaeOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__3" c_rdaeOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-rdaeOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__4" c_rdaeOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-rdaeOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__5" c_rdaeOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__5
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeOut__5 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__5 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__6" c_rdaeOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__6
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeOut__6 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__6 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__7" c_rdaeOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__7
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeOut__7 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__7 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__8" c_rdaeOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__8
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-rdaeOut__8 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__8 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__9" c_rdaeOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__9
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-rdaeOut__9 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__9 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__10" c_rdaeOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__10
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-rdaeOut__10 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__10 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__11" c_rdaeOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__11
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeOut__11 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__11 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__12" c_rdaeOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__12
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeOut__12 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__12 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__13" c_rdaeOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__13
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-rdaeOut__13 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__13 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__14" c_rdaeOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__14
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-rdaeOut__14 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__14 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__17" c_rdaeOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__17
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-rdaeOut__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__18" c_rdaeOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__18
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeOut__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__19" c_rdaeOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__19
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeOut__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__20" c_rdaeOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__20
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-rdaeOut__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "rdaeOut__21" c_rdaeOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-rdaeOut__21
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-rdaeOut__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_rdaeOut__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__0" c_sdpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__1" c_sdpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__2" c_sdpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__3" c_sdpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__4" c_sdpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__5" c_sdpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__6" c_sdpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__7" c_sdpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__8" c_sdpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__9" c_sdpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__10" c_sdpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__11" c_sdpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__12" c_sdpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__13" c_sdpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__14" c_sdpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__15" c_sdpIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__15
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__15 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__15 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__16" c_sdpIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__16
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpIn__16 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__16 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__17" c_sdpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__17
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__17 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__17 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__18" c_sdpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpIn__18 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__18 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__19" c_sdpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__19 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__20" c_sdpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpIn__20 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__21" c_sdpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__22" c_sdpIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__23" c_sdpIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__24" c_sdpIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__25" c_sdpIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__26" c_sdpIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__27" c_sdpIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__28" c_sdpIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__29" c_sdpIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__30" c_sdpIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__30
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__30 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__30 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__31" c_sdpIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__31
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpIn__31 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__31 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__32" c_sdpIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__32
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__32 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__32 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__33" c_sdpIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__33
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpIn__33 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__33 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__34" c_sdpIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__34
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__34 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__35" c_sdpIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__35
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpIn__35 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__36" c_sdpIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__36
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__37" c_sdpIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__37
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__38" c_sdpIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__38
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__39" c_sdpIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__39
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__40" c_sdpIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__40
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__41" c_sdpIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__41
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__42" c_sdpIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__42
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__43" c_sdpIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__43
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__44" c_sdpIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__44
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__47" c_sdpIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__47
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__47 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__47 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__48" c_sdpIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__48
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpIn__48 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__48 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__49" c_sdpIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__49
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__49 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__49 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__50" c_sdpIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__50
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpIn__50 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__50 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__51" c_sdpIn__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__51
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__51 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__52" c_sdpIn__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__52
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpIn__52 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__53" c_sdpIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__53
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__54" c_sdpIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__54
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__55" c_sdpIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__55
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__56" c_sdpIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__56
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__57" c_sdpIn__57
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__57
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__58" c_sdpIn__58
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__58
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__59" c_sdpIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__59
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__60" c_sdpIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__60
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpIn__61" c_sdpIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpIn__61
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__0" c_sdpOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__1" c_sdpOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__2" c_sdpOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__3" c_sdpOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__4" c_sdpOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__5" c_sdpOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__6" c_sdpOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__7" c_sdpOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__8" c_sdpOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__9" c_sdpOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__10" c_sdpOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__11" c_sdpOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdpOut__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__12" c_sdpOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdpOut__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__13" c_sdpOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__13
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpOut__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__14" c_sdpOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__14
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpOut__14 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__14 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__15" c_sdpOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__15
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpOut__15 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__15 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__16" c_sdpOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpOut__16 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__16 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__17" c_sdpOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpOut__17 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__17 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__18" c_sdpOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpOut__18 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__19" c_sdpOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpOut__19 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__20" c_sdpOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__21" c_sdpOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__22" c_sdpOut__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpOut__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__23" c_sdpOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__24" c_sdpOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdpOut__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__25" c_sdpOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdpOut__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__26" c_sdpOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__26
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-sdpOut__26 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__26 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__27" c_sdpOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__27
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpOut__27 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__27 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__28" c_sdpOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__28
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpOut__28 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__28 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__29" c_sdpOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__29
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpOut__29 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__29 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__30" c_sdpOut__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__30
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpOut__30 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__31" c_sdpOut__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpOut__31 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__32" c_sdpOut__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpOut__32 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__33" c_sdpOut__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__33
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpOut__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__34" c_sdpOut__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__34
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpOut__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__35" c_sdpOut__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__35
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpOut__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__36" c_sdpOut__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__36
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpOut__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__37" c_sdpOut__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__37
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdpOut__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__38" c_sdpOut__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__38
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdpOut__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__41" c_sdpOut__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__41
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-sdpOut__41 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__41 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__42" c_sdpOut__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__42
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpOut__42 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__42 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__43" c_sdpOut__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__43
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpOut__43 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__43 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__44" c_sdpOut__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__44
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpOut__44 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__44 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__45" c_sdpOut__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__45
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpOut__45 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__45 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__46" c_sdpOut__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__46
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpOut__46 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__47" c_sdpOut__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__47
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpOut__47 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__48" c_sdpOut__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__48
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpOut__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__49" c_sdpOut__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__49
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpOut__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__50" c_sdpOut__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__50
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpOut__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__51" c_sdpOut__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__51
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpOut__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__52" c_sdpOut__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__52
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdpOut__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdpOut__53" c_sdpOut__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdpOut__53
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdpOut__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdpOut__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__0" c_sdqpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__1" c_sdqpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__2" c_sdqpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__3" c_sdqpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__4" c_sdqpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__5" c_sdqpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__6" c_sdqpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__7" c_sdqpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__8" c_sdqpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__9" c_sdqpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__10" c_sdqpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__11" c_sdqpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__12" c_sdqpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__13" c_sdqpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__14" c_sdqpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__15" c_sdqpIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__15
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__16" c_sdqpIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__16
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__17" c_sdqpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__17
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__17 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__17 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__18" c_sdqpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__18
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__18 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__18 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__19" c_sdqpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__19
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__19 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__19 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__20" c_sdqpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__20 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__20 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__21" c_sdqpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__21 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__22" c_sdqpIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__22 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__23" c_sdqpIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__24" c_sdqpIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__25" c_sdqpIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__26" c_sdqpIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__27" c_sdqpIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__28" c_sdqpIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__29" c_sdqpIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__30" c_sdqpIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__30
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__31" c_sdqpIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__31
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__32" c_sdqpIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__32
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__33" c_sdqpIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__33
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__34" c_sdqpIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__34
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__34 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__34 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__35" c_sdqpIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__35
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__35 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__35 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__36" c_sdqpIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__36
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__36 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__36 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__37" c_sdqpIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__37
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__37 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__37 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__38" c_sdqpIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__38
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__38 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__39" c_sdqpIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__39
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__39 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__40" c_sdqpIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__40
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__41" c_sdqpIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__41
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__42" c_sdqpIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__42
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__43" c_sdqpIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__43
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__44" c_sdqpIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__44
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__45" c_sdqpIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__45
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__46" c_sdqpIn__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__46
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__47" c_sdqpIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__47
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__48" c_sdqpIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__48
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__49" c_sdqpIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__49
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__50" c_sdqpIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__50
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__53" c_sdqpIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__53
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__53 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__53 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__54" c_sdqpIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__54
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__54 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__54 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__55" c_sdqpIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__55
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__55 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__55 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__56" c_sdqpIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__56
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__56 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__56 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__57" c_sdqpIn__57
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__57
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__57 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__58" c_sdqpIn__58
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__58
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__58 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__59" c_sdqpIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__59
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__60" c_sdqpIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__60
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__61" c_sdqpIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__61
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__62" c_sdqpIn__62
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__62
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__63" c_sdqpIn__63
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__63
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__64" c_sdqpIn__64
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__64
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__65" c_sdqpIn__65
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__65
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__66" c_sdqpIn__66
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__66
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__67" c_sdqpIn__67
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__67
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__68" c_sdqpIn__68
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__68
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpIn__69" c_sdqpIn__69
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpIn__69
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__0" c_sdqpOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__1" c_sdqpOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__2" c_sdqpOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__3" c_sdqpOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__4" c_sdqpOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__5" c_sdqpOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__6" c_sdqpOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__7" c_sdqpOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__8" c_sdqpOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__9" c_sdqpOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__10" c_sdqpOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__11" c_sdqpOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__12" c_sdqpOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-sdqpOut__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__13" c_sdqpOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__13
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__13 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__13 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__14" c_sdqpOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__14
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__14 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__14 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__15" c_sdqpOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__15
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__15 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__15 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__16" c_sdqpOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__16 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__16 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__17" c_sdqpOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__17 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__17 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__18" c_sdqpOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__18 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__19" c_sdqpOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__19 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__20" c_sdqpOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__21" c_sdqpOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__22" c_sdqpOut__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__23" c_sdqpOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__24" c_sdqpOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__25" c_sdqpOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-sdqpOut__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__26" c_sdqpOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__26
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-sdqpOut__26 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__26 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__27" c_sdqpOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__27
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpOut__27 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__27 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__28" c_sdqpOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__28
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpOut__28 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__28 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__29" c_sdqpOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__29
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpOut__29 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__29 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__30" c_sdqpOut__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__30
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpOut__30 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__31" c_sdqpOut__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpOut__31 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__32" c_sdqpOut__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpOut__32 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__33" c_sdqpOut__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__33
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpOut__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__34" c_sdqpOut__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__34
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpOut__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__35" c_sdqpOut__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__35
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpOut__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__36" c_sdqpOut__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__36
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpOut__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__37" c_sdqpOut__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__37
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-sdqpOut__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__38" c_sdqpOut__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__38
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-sdqpOut__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__41" c_sdqpOut__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__41
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-sdqpOut__41 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__41 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__42" c_sdqpOut__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__42
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpOut__42 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__42 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__43" c_sdqpOut__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__43
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpOut__43 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__43 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__44" c_sdqpOut__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__44
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpOut__44 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__44 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__45" c_sdqpOut__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__45
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpOut__45 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__45 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__46" c_sdqpOut__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__46
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpOut__46 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__47" c_sdqpOut__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__47
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpOut__47 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__48" c_sdqpOut__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__48
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpOut__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__49" c_sdqpOut__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__49
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpOut__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__50" c_sdqpOut__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__50
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpOut__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__51" c_sdqpOut__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__51
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpOut__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__52" c_sdqpOut__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__52
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-sdqpOut__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sdqpOut__53" c_sdqpOut__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-sdqpOut__53
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-sdqpOut__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_sdqpOut__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIRK__0" c_simpleIRK__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction')
-simpleIRK__0
-  :: Function -> IO MXFunction
-simpleIRK__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIRK__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIRK__1" c_simpleIRK__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MXFunction')
-simpleIRK__1
-  :: Function -> Int -> IO MXFunction
-simpleIRK__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIRK__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIRK__2" c_simpleIRK__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MXFunction')
-simpleIRK__2
-  :: Function -> Int -> Int -> IO MXFunction
-simpleIRK__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIRK__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIRK__3" c_simpleIRK__3
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> IO (Ptr MXFunction')
-simpleIRK__3
-  :: Function -> Int -> Int -> String -> IO MXFunction
-simpleIRK__3 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIRK__3 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIRK__4" c_simpleIRK__4
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> Ptr StdString -> IO (Ptr MXFunction')
-simpleIRK__4
-  :: Function -> Int -> Int -> String -> String -> IO MXFunction
-simpleIRK__4 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIRK__4 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIRK__5" c_simpleIRK__5
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction')
-simpleIRK__5
-  :: Function -> Int -> Int -> String -> String -> M.Map String GenericType -> IO MXFunction
-simpleIRK__5 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIRK__5 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIntegrator__0" c_simpleIntegrator__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction')
-simpleIntegrator__0
-  :: Function -> IO MXFunction
-simpleIntegrator__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIntegrator__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIntegrator__1" c_simpleIntegrator__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MXFunction')
-simpleIntegrator__1
-  :: Function -> String -> IO MXFunction
-simpleIntegrator__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIntegrator__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleIntegrator__2" c_simpleIntegrator__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction')
-simpleIntegrator__2
-  :: Function -> String -> M.Map String GenericType -> IO MXFunction
-simpleIntegrator__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleIntegrator__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleRK__0" c_simpleRK__0
-  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction')
-simpleRK__0
-  :: Function -> IO MXFunction
-simpleRK__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleRK__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleRK__1" c_simpleRK__1
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MXFunction')
-simpleRK__1
-  :: Function -> Int -> IO MXFunction
-simpleRK__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleRK__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simpleRK__2" c_simpleRK__2
-  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MXFunction')
-simpleRK__2
-  :: Function -> Int -> Int -> IO MXFunction
-simpleRK__2 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_simpleRK__2 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__0" c_socpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__1" c_socpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__2" c_socpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__3" c_socpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__4" c_socpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__5" c_socpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__6" c_socpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__7" c_socpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__8" c_socpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__9" c_socpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__10" c_socpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__11" c_socpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__12" c_socpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__13" c_socpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__14" c_socpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__15" c_socpIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__15
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__16" c_socpIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__16
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__17" c_socpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__17
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__18" c_socpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__18
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__19" c_socpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__19
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__19 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__19 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__20" c_socpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__20
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__20 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__20 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__21" c_socpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__21
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__21 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__21 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__22" c_socpIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__22
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__22 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__22 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__23" c_socpIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__23
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__23 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__24" c_socpIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__24
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__24 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__25" c_socpIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__25
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__26" c_socpIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__27" c_socpIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__28" c_socpIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__29" c_socpIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__30" c_socpIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__30
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__31" c_socpIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__31
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__32" c_socpIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__32
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__33" c_socpIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__33
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__34" c_socpIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__34
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__35" c_socpIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__35
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__36" c_socpIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__36
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__37" c_socpIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__37
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__38" c_socpIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__38
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__38 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__38 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__39" c_socpIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__39
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__39 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__39 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__40" c_socpIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__40
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__40 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__40 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__41" c_socpIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__41
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__41 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__41 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__42" c_socpIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__42
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__42 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__43" c_socpIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__43
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__43 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__44" c_socpIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__44
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__45" c_socpIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__45
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__46" c_socpIn__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__46
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__47" c_socpIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__47
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__48" c_socpIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__48
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__49" c_socpIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__49
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__50" c_socpIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__50
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__51" c_socpIn__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__51
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__52" c_socpIn__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__52
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__53" c_socpIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__53
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__54" c_socpIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__54
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__55" c_socpIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__55
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__56" c_socpIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__56
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__59" c_socpIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__59
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__59 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__59 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__60" c_socpIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__60
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__60 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__60 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__61" c_socpIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__61
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__61 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__61 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__62" c_socpIn__62
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__62
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__62 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__62 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__63" c_socpIn__63
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__63
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__63 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__64" c_socpIn__64
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__64
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__64 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__65" c_socpIn__65
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__65
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__66" c_socpIn__66
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__66
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__67" c_socpIn__67
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__67
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__68" c_socpIn__68
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__68
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__69" c_socpIn__69
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__69
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__70" c_socpIn__70
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__70
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__70 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__70 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__71" c_socpIn__71
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__71
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__71 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__71 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__72" c_socpIn__72
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__72
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__72 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__72 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__73" c_socpIn__73
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__73
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__73 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__73 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__74" c_socpIn__74
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__74
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__74 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__74 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__75" c_socpIn__75
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__75
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__75 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__75 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__76" c_socpIn__76
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__76
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpIn__76 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__76 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpIn__77" c_socpIn__77
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpIn__77
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpIn__77 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpIn__77 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__0" c_socpOut__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpOut__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__1" c_socpOut__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpOut__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__2" c_socpOut__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpOut__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__3" c_socpOut__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpOut__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__4" c_socpOut__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpOut__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__5" c_socpOut__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpOut__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__6" c_socpOut__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__7" c_socpOut__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__8" c_socpOut__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__9" c_socpOut__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__10" c_socpOut__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__11" c_socpOut__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__11
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpOut__11 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__11 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__12" c_socpOut__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__12
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpOut__12 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__12 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__13" c_socpOut__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__13
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpOut__13 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__13 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__14" c_socpOut__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__14
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpOut__14 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__14 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__15" c_socpOut__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__15
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpOut__15 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__15 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__16" c_socpOut__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__16
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpOut__16 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__17" c_socpOut__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__17
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpOut__17 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__18" c_socpOut__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__18
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpOut__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__19" c_socpOut__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__19
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpOut__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__20" c_socpOut__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__20
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-socpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__21" c_socpOut__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__21
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-socpOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__22" c_socpOut__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__22
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-socpOut__22 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__22 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__23" c_socpOut__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__23
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpOut__23 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__23 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__24" c_socpOut__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__24
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpOut__24 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__24 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__25" c_socpOut__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__25
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpOut__25 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__25 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__26" c_socpOut__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__26
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpOut__26 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__26 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__27" c_socpOut__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__27
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpOut__27 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__28" c_socpOut__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__28
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpOut__28 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__29" c_socpOut__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__29
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__30" c_socpOut__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__30
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpOut__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__31" c_socpOut__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__31
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-socpOut__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__32" c_socpOut__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__32
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-socpOut__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__35" c_socpOut__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__35
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-socpOut__35 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__35 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__36" c_socpOut__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__36
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpOut__36 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__36 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__37" c_socpOut__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__37
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpOut__37 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__37 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__38" c_socpOut__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__38
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpOut__38 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__38 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__39" c_socpOut__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__39
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpOut__39 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__39 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__40" c_socpOut__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__40
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpOut__40 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__41" c_socpOut__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__41
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpOut__41 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__42" c_socpOut__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__42
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpOut__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__43" c_socpOut__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__43
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpOut__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__44" c_socpOut__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__44
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-socpOut__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpOut__45" c_socpOut__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-socpOut__45
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-socpOut__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpStruct__2" c_socpStruct__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpStruct__2
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpStruct__2 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpStruct__2 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpStruct__3" c_socpStruct__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpStruct__3
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpStruct__3 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpStruct__3 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpStruct__4" c_socpStruct__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpStruct__4
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpStruct__4 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpStruct__4 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpStruct__5" c_socpStruct__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpStruct__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-socpStruct__5 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpStruct__5 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "socpStruct__6" c_socpStruct__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-socpStruct__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-socpStruct__6 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_socpStruct__6 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__0" c_stabilizedQpIn__0
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__0
-  :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__0 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__0 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__1" c_stabilizedQpIn__1
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__1
-  :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__1 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__1 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__2" c_stabilizedQpIn__2
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__2
-  :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__2 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__2 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__3" c_stabilizedQpIn__3
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__3
-  :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__3 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__3 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__4" c_stabilizedQpIn__4
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__4
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__4 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__5" c_stabilizedQpIn__5
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__5
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__5 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__6" c_stabilizedQpIn__6
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__6
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__7" c_stabilizedQpIn__7
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__7
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__8" c_stabilizedQpIn__8
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__8
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__9" c_stabilizedQpIn__9
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__9
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__10" c_stabilizedQpIn__10
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__10
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__11" c_stabilizedQpIn__11
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__11
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__12" c_stabilizedQpIn__12
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__12
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__13" c_stabilizedQpIn__13
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__13
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__14" c_stabilizedQpIn__14
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__14
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__15" c_stabilizedQpIn__15
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__15
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__16" c_stabilizedQpIn__16
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__16
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__17" c_stabilizedQpIn__17
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__17
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__18" c_stabilizedQpIn__18
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__18
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__19" c_stabilizedQpIn__19
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__19
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__20" c_stabilizedQpIn__20
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__20
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__21" c_stabilizedQpIn__21
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__21
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__22" c_stabilizedQpIn__22
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__22
-  :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String)
-stabilizedQpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__23" c_stabilizedQpIn__23
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__23
-  :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__23 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__23 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__24" c_stabilizedQpIn__24
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__24
-  :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__24 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__24 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__25" c_stabilizedQpIn__25
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__25
-  :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__25 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__25 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__26" c_stabilizedQpIn__26
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__26
-  :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__26 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__26 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__27" c_stabilizedQpIn__27
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__27
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__27 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__28" c_stabilizedQpIn__28
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__28
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__28 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__29" c_stabilizedQpIn__29
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__29
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__30" c_stabilizedQpIn__30
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__30
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__31" c_stabilizedQpIn__31
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__31
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__32" c_stabilizedQpIn__32
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__32
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__33" c_stabilizedQpIn__33
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__33
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__34" c_stabilizedQpIn__34
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__34
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__35" c_stabilizedQpIn__35
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__35
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__36" c_stabilizedQpIn__36
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__36
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__37" c_stabilizedQpIn__37
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__37
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__38" c_stabilizedQpIn__38
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__38
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__39" c_stabilizedQpIn__39
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__39
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__40" c_stabilizedQpIn__40
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__40
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__41" c_stabilizedQpIn__41
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__41
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__42" c_stabilizedQpIn__42
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__42
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__43" c_stabilizedQpIn__43
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__43
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__44" c_stabilizedQpIn__44
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__44
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__45" c_stabilizedQpIn__45
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__45
-  :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String)
-stabilizedQpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__46" c_stabilizedQpIn__46
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__46
-  :: String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__46 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__46 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__47" c_stabilizedQpIn__47
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__47
-  :: String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__47 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__47 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__48" c_stabilizedQpIn__48
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__48
-  :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__48 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__48 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__49" c_stabilizedQpIn__49
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__49
-  :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__49 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__49 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__50" c_stabilizedQpIn__50
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__50
-  :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__50 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__51" c_stabilizedQpIn__51
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__51
-  :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__51 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__52" c_stabilizedQpIn__52
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__52
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__52 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__53" c_stabilizedQpIn__53
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__53
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__54" c_stabilizedQpIn__54
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__54
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__55" c_stabilizedQpIn__55
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__55
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__56" c_stabilizedQpIn__56
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__56
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__57" c_stabilizedQpIn__57
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__57
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__58" c_stabilizedQpIn__58
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__58
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__59" c_stabilizedQpIn__59
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__59
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__60" c_stabilizedQpIn__60
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__60
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__61" c_stabilizedQpIn__61
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__61
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__62" c_stabilizedQpIn__62
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__62
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__63" c_stabilizedQpIn__63
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__63
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__64" c_stabilizedQpIn__64
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__64
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__65" c_stabilizedQpIn__65
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__65
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__66" c_stabilizedQpIn__66
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__66
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__67" c_stabilizedQpIn__67
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__67
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__68" c_stabilizedQpIn__68
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__68
-  :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String)
-stabilizedQpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__71" c_stabilizedQpIn__71
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__71
-  :: String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__71 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__71 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__72" c_stabilizedQpIn__72
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__72
-  :: String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__72 x0 x1 x2 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__72 errStrPtrP x0' x1' x2'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__73" c_stabilizedQpIn__73
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__73
-  :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__73 x0 x1 x2 x3 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__73 errStrPtrP x0' x1' x2' x3'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__74" c_stabilizedQpIn__74
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__74
-  :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__74 x0 x1 x2 x3 x4 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__74 errStrPtrP x0' x1' x2' x3' x4'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__75" c_stabilizedQpIn__75
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__75
-  :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__75 x0 x1 x2 x3 x4 x5 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__75 errStrPtrP x0' x1' x2' x3' x4' x5'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__76" c_stabilizedQpIn__76
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__76
-  :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__76 x0 x1 x2 x3 x4 x5 x6 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__76 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__77" c_stabilizedQpIn__77
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__77
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__77 x0 x1 x2 x3 x4 x5 x6 x7 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__77 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__78" c_stabilizedQpIn__78
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__78
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__78 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__78 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__79" c_stabilizedQpIn__79
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__79
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__79 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__79 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__80" c_stabilizedQpIn__80
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__80
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__80 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__80 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__81" c_stabilizedQpIn__81
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__81
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__81 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__81 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__82" c_stabilizedQpIn__82
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__82
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__82 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__82 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__83" c_stabilizedQpIn__83
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__83
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__83 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__83 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__84" c_stabilizedQpIn__84
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__84
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__84 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__84 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__85" c_stabilizedQpIn__85
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__85
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__85 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__85 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__86" c_stabilizedQpIn__86
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__86
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__86 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__86 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__87" c_stabilizedQpIn__87
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__87
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__87 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__87 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__88" c_stabilizedQpIn__88
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__88
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__88 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__88 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__89" c_stabilizedQpIn__89
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__89
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__89 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__89 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__90" c_stabilizedQpIn__90
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__90
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__90 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__90 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__91" c_stabilizedQpIn__91
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__91
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__91 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__91 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__92" c_stabilizedQpIn__92
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__92
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__92 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__92 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "stabilizedQpIn__93" c_stabilizedQpIn__93
-  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))))
-stabilizedQpIn__93
-  :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String)
-stabilizedQpIn__93 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  withMarshal x2 $ \x2' ->
-  withMarshal x3 $ \x3' ->
-  withMarshal x4 $ \x4' ->
-  withMarshal x5 $ \x5' ->
-  withMarshal x6 $ \x6' ->
-  withMarshal x7 $ \x7' ->
-  withMarshal x8 $ \x8' ->
-  withMarshal x9 $ \x9' ->
-  withMarshal x10 $ \x10' ->
-  withMarshal x11 $ \x11' ->
-  withMarshal x12 $ \x12' ->
-  withMarshal x13 $ \x13' ->
-  withMarshal x14 $ \x14' ->
-  withMarshal x15 $ \x15' ->
-  withMarshal x16 $ \x16' ->
-  withMarshal x17 $ \x17' ->
-  withMarshal x18 $ \x18' ->
-  withMarshal x19 $ \x19' ->
-  withMarshal x20 $ \x20' ->
-  withMarshal x21 $ \x21' ->
-  withMarshal x22 $ \x22' ->
-  withMarshal x23 $ \x23' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_stabilizedQpIn__93 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+         casadi_abs__4,
+         casadi_acos__0,
+         casadi_acos__1,
+         casadi_acos__2,
+         casadi_acos__3,
+         casadi_acos__4,
+         casadi_acosh__0,
+         casadi_acosh__1,
+         casadi_acosh__2,
+         casadi_acosh__3,
+         casadi_acosh__4,
+         casadi_adj__0,
+         casadi_adj__1,
+         casadi_adj__2,
+         casadi_all__0,
+         casadi_all__1,
+         casadi_all__2,
+         casadi_and__0,
+         casadi_and__1,
+         casadi_and__2,
+         casadi_and__3,
+         casadi_and__4,
+         casadi_any__0,
+         casadi_any__1,
+         casadi_any__2,
+         casadi_asin__0,
+         casadi_asin__1,
+         casadi_asin__2,
+         casadi_asin__3,
+         casadi_asin__4,
+         casadi_asinh__0,
+         casadi_asinh__1,
+         casadi_asinh__2,
+         casadi_asinh__3,
+         casadi_asinh__4,
+         casadi_atan2__0,
+         casadi_atan2__1,
+         casadi_atan2__2,
+         casadi_atan2__3,
+         casadi_atan2__4,
+         casadi_atan__0,
+         casadi_atan__1,
+         casadi_atan__2,
+         casadi_atan__3,
+         casadi_atan__4,
+         casadi_atanh__0,
+         casadi_atanh__1,
+         casadi_atanh__2,
+         casadi_atanh__3,
+         casadi_atanh__4,
+         casadi_bilin__0,
+         casadi_bilin__1,
+         casadi_bilin__2,
+         casadi_bilin__3,
+         casadi_blockcat__0,
+         casadi_blockcat__1,
+         casadi_blockcat__2,
+         casadi_blockcat__3,
+         casadi_blockcat__4,
+         casadi_blockcat__5,
+         casadi_blockcat__6,
+         casadi_blockcat__7,
+         casadi_blockcat__8,
+         casadi_blockcat__9,
+         casadi_blocksplit__0,
+         casadi_blocksplit__1,
+         casadi_blocksplit__10,
+         casadi_blocksplit__11,
+         casadi_blocksplit__12,
+         casadi_blocksplit__13,
+         casadi_blocksplit__14,
+         casadi_blocksplit__15,
+         casadi_blocksplit__16,
+         casadi_blocksplit__17,
+         casadi_blocksplit__18,
+         casadi_blocksplit__19,
+         casadi_blocksplit__2,
+         casadi_blocksplit__3,
+         casadi_blocksplit__4,
+         casadi_blocksplit__5,
+         casadi_blocksplit__6,
+         casadi_blocksplit__7,
+         casadi_blocksplit__8,
+         casadi_blocksplit__9,
+         casadi_ceil__0,
+         casadi_ceil__1,
+         casadi_ceil__2,
+         casadi_ceil__3,
+         casadi_ceil__4,
+         casadi_chol__0,
+         casadi_chol__1,
+         casadi_chol__2,
+         casadi_cofactor__0,
+         casadi_cofactor__1,
+         casadi_cofactor__2,
+         casadi_conditional__0,
+         casadi_conditional__1,
+         casadi_conditional__2,
+         casadi_conditional__3,
+         casadi_conditional__4,
+         casadi_conditional__5,
+         casadi_conditional__6,
+         casadi_conditional__7,
+         casadi_constpow__0,
+         casadi_constpow__1,
+         casadi_constpow__2,
+         casadi_constpow__3,
+         casadi_constpow__4,
+         casadi_copysign__0,
+         casadi_copysign__1,
+         casadi_copysign__2,
+         casadi_copysign__3,
+         casadi_copysign__4,
+         casadi_cos__0,
+         casadi_cos__1,
+         casadi_cos__2,
+         casadi_cos__3,
+         casadi_cos__4,
+         casadi_cosh__0,
+         casadi_cosh__1,
+         casadi_cosh__2,
+         casadi_cosh__3,
+         casadi_cosh__4,
+         casadi_cross__0,
+         casadi_cross__1,
+         casadi_cross__2,
+         casadi_cross__3,
+         casadi_cross__4,
+         casadi_cross__5,
+         casadi_cross__6,
+         casadi_cross__7,
+         casadi_densify__0,
+         casadi_densify__1,
+         casadi_densify__2,
+         casadi_densify__3,
+         casadi_depends_on__0,
+         casadi_depends_on__1,
+         casadi_depends_on__2,
+         casadi_depends_on__3,
+         casadi_det__0,
+         casadi_det__1,
+         casadi_det__2,
+         casadi_det__3,
+         casadi_diag__0,
+         casadi_diag__1,
+         casadi_diag__2,
+         casadi_diag__3,
+         casadi_diagcat__0,
+         casadi_diagcat__1,
+         casadi_diagcat__2,
+         casadi_diagcat__3,
+         casadi_diagcat__4,
+         casadi_diagsplit__0,
+         casadi_diagsplit__1,
+         casadi_diagsplit__10,
+         casadi_diagsplit__11,
+         casadi_diagsplit__12,
+         casadi_diagsplit__13,
+         casadi_diagsplit__14,
+         casadi_diagsplit__15,
+         casadi_diagsplit__16,
+         casadi_diagsplit__17,
+         casadi_diagsplit__18,
+         casadi_diagsplit__19,
+         casadi_diagsplit__2,
+         casadi_diagsplit__20,
+         casadi_diagsplit__21,
+         casadi_diagsplit__22,
+         casadi_diagsplit__23,
+         casadi_diagsplit__24,
+         casadi_diagsplit__3,
+         casadi_diagsplit__4,
+         casadi_diagsplit__5,
+         casadi_diagsplit__6,
+         casadi_diagsplit__7,
+         casadi_diagsplit__8,
+         casadi_diagsplit__9,
+         casadi_dot__0,
+         casadi_dot__1,
+         casadi_dot__2,
+         casadi_dot__3,
+         casadi_eig_symbolic__0,
+         casadi_eig_symbolic__1,
+         casadi_eig_symbolic__2,
+         casadi_eq__0,
+         casadi_eq__1,
+         casadi_eq__2,
+         casadi_eq__3,
+         casadi_eq__4,
+         casadi_erf__0,
+         casadi_erf__1,
+         casadi_erf__2,
+         casadi_erf__3,
+         casadi_erf__4,
+         casadi_erfinv__0,
+         casadi_erfinv__1,
+         casadi_erfinv__2,
+         casadi_erfinv__3,
+         casadi_erfinv__4,
+         casadi_exp__0,
+         casadi_exp__1,
+         casadi_exp__2,
+         casadi_exp__3,
+         casadi_exp__4,
+         casadi_expand__0,
+         casadi_expand__1,
+         casadi_expand__2,
+         casadi_find,
+         casadi_floor__0,
+         casadi_floor__1,
+         casadi_floor__2,
+         casadi_floor__3,
+         casadi_floor__4,
+         casadi_gauss_quadrature__0,
+         casadi_gauss_quadrature__1,
+         casadi_gauss_quadrature__2,
+         casadi_gauss_quadrature__3,
+         casadi_gauss_quadrature__4,
+         casadi_gauss_quadrature__5,
+         casadi_gauss_quadrature__6,
+         casadi_gauss_quadrature__7,
+         casadi_gauss_quadrature__8,
+         casadi_ge__0,
+         casadi_ge__1,
+         casadi_ge__2,
+         casadi_ge__3,
+         casadi_ge__4,
+         casadi_getMinor__0,
+         casadi_getMinor__1,
+         casadi_getMinor__2,
+         casadi_gradient__0,
+         casadi_gradient__1,
+         casadi_gradient__2,
+         casadi_gradient__3,
+         casadi_graph_substitute__0,
+         casadi_graph_substitute__1,
+         casadi_gt__0,
+         casadi_gt__1,
+         casadi_gt__2,
+         casadi_gt__3,
+         casadi_gt__4,
+         casadi_heaviside__0,
+         casadi_heaviside__1,
+         casadi_heaviside__2,
+         casadi_hessian__0,
+         casadi_hessian__1,
+         casadi_hessian__2,
+         casadi_hessian__3,
+         casadi_horzcat__0,
+         casadi_horzcat__1,
+         casadi_horzcat__2,
+         casadi_horzcat__3,
+         casadi_horzcat__4,
+         casadi_horzsplit__0,
+         casadi_horzsplit__1,
+         casadi_horzsplit__10,
+         casadi_horzsplit__11,
+         casadi_horzsplit__12,
+         casadi_horzsplit__13,
+         casadi_horzsplit__14,
+         casadi_horzsplit__2,
+         casadi_horzsplit__3,
+         casadi_horzsplit__4,
+         casadi_horzsplit__5,
+         casadi_horzsplit__6,
+         casadi_horzsplit__7,
+         casadi_horzsplit__8,
+         casadi_horzsplit__9,
+         casadi_if_else__0,
+         casadi_if_else__1,
+         casadi_if_else__2,
+         casadi_if_else__3,
+         casadi_if_else__4,
+         casadi_if_else__5,
+         casadi_if_else__6,
+         casadi_if_else__7,
+         casadi_inv__0,
+         casadi_inv__1,
+         casadi_inv__2,
+         casadi_inv__3,
+         casadi_inv_skew__0,
+         casadi_inv_skew__1,
+         casadi_inv_skew__2,
+         casadi_inv_skew__3,
+         casadi_is_equal__0,
+         casadi_is_equal__1,
+         casadi_is_equal__2,
+         casadi_is_equal__3,
+         casadi_is_equal__4,
+         casadi_is_equal__5,
+         casadi_is_equal__6,
+         casadi_is_equal__7,
+         casadi_is_equal__8,
+         casadi_is_equal__9,
+         casadi_jacobian__0,
+         casadi_jacobian__1,
+         casadi_jacobian__2,
+         casadi_jacobian__3,
+         casadi_jtimes__0,
+         casadi_jtimes__1,
+         casadi_jtimes__2,
+         casadi_jtimes__3,
+         casadi_jtimes__4,
+         casadi_jtimes__5,
+         casadi_jtimes__6,
+         casadi_jtimes__7,
+         casadi_kron__0,
+         casadi_kron__1,
+         casadi_kron__2,
+         casadi_kron__3,
+         casadi_kron__4,
+         casadi_ldivide__0,
+         casadi_ldivide__1,
+         casadi_ldivide__2,
+         casadi_ldivide__3,
+         casadi_ldivide__4,
+         casadi_le__0,
+         casadi_le__1,
+         casadi_le__2,
+         casadi_le__3,
+         casadi_le__4,
+         casadi_linspace__0,
+         casadi_linspace__1,
+         casadi_linspace__2,
+         casadi_linspace__3,
+         casadi_log10__0,
+         casadi_log10__1,
+         casadi_log10__2,
+         casadi_log10__3,
+         casadi_log10__4,
+         casadi_log__0,
+         casadi_log__1,
+         casadi_log__2,
+         casadi_log__3,
+         casadi_log__4,
+         casadi_lt__0,
+         casadi_lt__1,
+         casadi_lt__2,
+         casadi_lt__3,
+         casadi_lt__4,
+         casadi_mac__0,
+         casadi_mac__1,
+         casadi_mac__2,
+         casadi_mac__3,
+         casadi_mac__4,
+         casadi_matrix_expand__0,
+         casadi_matrix_expand__1,
+         casadi_matrix_expand__2,
+         casadi_matrix_expand__3,
+         casadi_matrix_expand__4,
+         casadi_matrix_expand__5,
+         casadi_max__0,
+         casadi_max__1,
+         casadi_max__2,
+         casadi_max__3,
+         casadi_max__4,
+         casadi_min__0,
+         casadi_min__1,
+         casadi_min__2,
+         casadi_min__3,
+         casadi_min__4,
+         casadi_minus__0,
+         casadi_minus__1,
+         casadi_minus__2,
+         casadi_minus__3,
+         casadi_minus__4,
+         casadi_mldivide__0,
+         casadi_mldivide__1,
+         casadi_mldivide__2,
+         casadi_mldivide__3,
+         casadi_mod__0,
+         casadi_mod__1,
+         casadi_mod__2,
+         casadi_mod__3,
+         casadi_mod__4,
+         casadi_mpower__0,
+         casadi_mpower__1,
+         casadi_mpower__2,
+         casadi_mpower__3,
+         casadi_mrdivide__0,
+         casadi_mrdivide__1,
+         casadi_mrdivide__2,
+         casadi_mrdivide__3,
+         casadi_mtaylor__0,
+         casadi_mtaylor__1,
+         casadi_mtaylor__2,
+         casadi_mtaylor__3,
+         casadi_mtaylor__4,
+         casadi_mtaylor__5,
+         casadi_mtaylor__6,
+         casadi_mtaylor__7,
+         casadi_mtaylor__8,
+         casadi_mtimes__0,
+         casadi_mtimes__1,
+         casadi_mtimes__2,
+         casadi_mtimes__3,
+         casadi_mtimes__4,
+         casadi_mtimes__5,
+         casadi_mtimes__6,
+         casadi_mtimes__7,
+         casadi_mtimes__8,
+         casadi_mtimes__9,
+         casadi_n_nodes__0,
+         casadi_n_nodes__1,
+         casadi_n_nodes__2,
+         casadi_n_nodes__3,
+         casadi_ne__0,
+         casadi_ne__1,
+         casadi_ne__2,
+         casadi_ne__3,
+         casadi_ne__4,
+         casadi_nl_var__0,
+         casadi_nl_var__1,
+         casadi_nl_var__2,
+         casadi_nl_var__3,
+         casadi_norm_0_mul__0,
+         casadi_norm_0_mul__1,
+         casadi_norm_0_mul__2,
+         casadi_norm_0_mul__3,
+         casadi_norm_0_mul__4,
+         casadi_norm_1__0,
+         casadi_norm_1__1,
+         casadi_norm_1__2,
+         casadi_norm_1__3,
+         casadi_norm_2__0,
+         casadi_norm_2__1,
+         casadi_norm_2__2,
+         casadi_norm_2__3,
+         casadi_norm_F__0,
+         casadi_norm_F__1,
+         casadi_norm_F__2,
+         casadi_norm_F__3,
+         casadi_norm_inf__0,
+         casadi_norm_inf__1,
+         casadi_norm_inf__2,
+         casadi_norm_inf__3,
+         casadi_norm_inf_mul__0,
+         casadi_norm_inf_mul__1,
+         casadi_norm_inf_mul__2,
+         casadi_not__0,
+         casadi_not__1,
+         casadi_not__2,
+         casadi_not__3,
+         casadi_not__4,
+         casadi_nullspace__0,
+         casadi_nullspace__1,
+         casadi_nullspace__2,
+         casadi_nullspace__3,
+         casadi_offset__0,
+         casadi_offset__1,
+         casadi_offset__2,
+         casadi_offset__3,
+         casadi_offset__4,
+         casadi_offset__5,
+         casadi_offset__6,
+         casadi_offset__7,
+         casadi_offset__8,
+         casadi_offset__9,
+         casadi_or__0,
+         casadi_or__1,
+         casadi_or__2,
+         casadi_or__3,
+         casadi_or__4,
+         casadi_pinv__0,
+         casadi_pinv__1,
+         casadi_pinv__10,
+         casadi_pinv__11,
+         casadi_pinv__2,
+         casadi_pinv__3,
+         casadi_pinv__4,
+         casadi_pinv__5,
+         casadi_pinv__6,
+         casadi_pinv__7,
+         casadi_pinv__8,
+         casadi_pinv__9,
+         casadi_plus__0,
+         casadi_plus__1,
+         casadi_plus__2,
+         casadi_plus__3,
+         casadi_plus__4,
+         casadi_poly_coeff__0,
+         casadi_poly_coeff__1,
+         casadi_poly_coeff__2,
+         casadi_poly_roots__0,
+         casadi_poly_roots__1,
+         casadi_poly_roots__2,
+         casadi_polyval__0,
+         casadi_polyval__1,
+         casadi_polyval__2,
+         casadi_polyval__3,
+         casadi_power__0,
+         casadi_power__1,
+         casadi_power__2,
+         casadi_power__3,
+         casadi_power__4,
+         casadi_print_operator__0,
+         casadi_print_operator__1,
+         casadi_print_operator__2,
+         casadi_print_operator__3,
+         casadi_project__0,
+         casadi_project__1,
+         casadi_project__2,
+         casadi_project__3,
+         casadi_project__4,
+         casadi_project__5,
+         casadi_project__6,
+         casadi_project__7,
+         casadi_pw_const__0,
+         casadi_pw_const__1,
+         casadi_pw_const__2,
+         casadi_pw_lin__0,
+         casadi_pw_lin__1,
+         casadi_pw_lin__2,
+         casadi_qr__0,
+         casadi_qr__1,
+         casadi_qr__2,
+         casadi_ramp__0,
+         casadi_ramp__1,
+         casadi_ramp__2,
+         casadi_rank1__0,
+         casadi_rank1__1,
+         casadi_rank1__2,
+         casadi_rank1__3,
+         casadi_rdivide__0,
+         casadi_rdivide__1,
+         casadi_rdivide__2,
+         casadi_rdivide__3,
+         casadi_rdivide__4,
+         casadi_rectangle__0,
+         casadi_rectangle__1,
+         casadi_rectangle__2,
+         casadi_repmat__0,
+         casadi_repmat__1,
+         casadi_repmat__10,
+         casadi_repmat__11,
+         casadi_repmat__12,
+         casadi_repmat__13,
+         casadi_repmat__14,
+         casadi_repmat__2,
+         casadi_repmat__3,
+         casadi_repmat__4,
+         casadi_repmat__5,
+         casadi_repmat__6,
+         casadi_repmat__7,
+         casadi_repmat__8,
+         casadi_repmat__9,
+         casadi_repsum__0,
+         casadi_repsum__1,
+         casadi_repsum__2,
+         casadi_repsum__3,
+         casadi_repsum__4,
+         casadi_repsum__5,
+         casadi_repsum__6,
+         casadi_repsum__7,
+         casadi_reshape__0,
+         casadi_reshape__1,
+         casadi_reshape__10,
+         casadi_reshape__11,
+         casadi_reshape__12,
+         casadi_reshape__13,
+         casadi_reshape__14,
+         casadi_reshape__2,
+         casadi_reshape__3,
+         casadi_reshape__4,
+         casadi_reshape__5,
+         casadi_reshape__6,
+         casadi_reshape__7,
+         casadi_reshape__8,
+         casadi_reshape__9,
+         casadi_shared__0,
+         casadi_shared__1,
+         casadi_shared__10,
+         casadi_shared__11,
+         casadi_shared__2,
+         casadi_shared__3,
+         casadi_shared__4,
+         casadi_shared__5,
+         casadi_shared__6,
+         casadi_shared__7,
+         casadi_shared__8,
+         casadi_shared__9,
+         casadi_sign__0,
+         casadi_sign__1,
+         casadi_sign__2,
+         casadi_sign__3,
+         casadi_sign__4,
+         casadi_simplify__0,
+         casadi_simplify__1,
+         casadi_simplify__2,
+         casadi_simplify__3,
+         casadi_simplify__4,
+         casadi_sin__0,
+         casadi_sin__1,
+         casadi_sin__2,
+         casadi_sin__3,
+         casadi_sin__4,
+         casadi_sinh__0,
+         casadi_sinh__1,
+         casadi_sinh__2,
+         casadi_sinh__3,
+         casadi_sinh__4,
+         casadi_skew__0,
+         casadi_skew__1,
+         casadi_skew__2,
+         casadi_skew__3,
+         casadi_solve__0,
+         casadi_solve__1,
+         casadi_solve__10,
+         casadi_solve__11,
+         casadi_solve__2,
+         casadi_solve__3,
+         casadi_solve__4,
+         casadi_solve__5,
+         casadi_solve__6,
+         casadi_solve__7,
+         casadi_solve__8,
+         casadi_solve__9,
+         casadi_sparsify__0,
+         casadi_sparsify__1,
+         casadi_sparsify__2,
+         casadi_sparsify__3,
+         casadi_sparsify__4,
+         casadi_sparsify__5,
+         casadi_sprank__0,
+         casadi_sprank__1,
+         casadi_sprank__2,
+         casadi_sprank__3,
+         casadi_sprank__4,
+         casadi_sqrt__0,
+         casadi_sqrt__1,
+         casadi_sqrt__2,
+         casadi_sqrt__3,
+         casadi_sqrt__4,
+         casadi_substitute__0,
+         casadi_substitute__1,
+         casadi_substitute__2,
+         casadi_substitute__3,
+         casadi_substitute__4,
+         casadi_substitute__5,
+         casadi_substitute__6,
+         casadi_substitute__7,
+         casadi_substitute_inplace__0,
+         casadi_substitute_inplace__1,
+         casadi_substitute_inplace__2,
+         casadi_substitute_inplace__3,
+         casadi_substitute_inplace__4,
+         casadi_substitute_inplace__5,
+         casadi_substitute_inplace__6,
+         casadi_substitute_inplace__7,
+         casadi_sum1__0,
+         casadi_sum1__1,
+         casadi_sum1__2,
+         casadi_sum1__3,
+         casadi_sum2__0,
+         casadi_sum2__1,
+         casadi_sum2__2,
+         casadi_sum2__3,
+         casadi_sum_square__0,
+         casadi_sum_square__1,
+         casadi_sum_square__2,
+         casadi_sum_square__3,
+         casadi_symvar__0,
+         casadi_symvar__1,
+         casadi_symvar__2,
+         casadi_symvar__3,
+         casadi_tan__0,
+         casadi_tan__1,
+         casadi_tan__2,
+         casadi_tan__3,
+         casadi_tan__4,
+         casadi_tangent__0,
+         casadi_tangent__1,
+         casadi_tangent__2,
+         casadi_tangent__3,
+         casadi_tanh__0,
+         casadi_tanh__1,
+         casadi_tanh__2,
+         casadi_tanh__3,
+         casadi_tanh__4,
+         casadi_taylor__0,
+         casadi_taylor__1,
+         casadi_taylor__2,
+         casadi_taylor__3,
+         casadi_taylor__4,
+         casadi_taylor__5,
+         casadi_taylor__6,
+         casadi_taylor__7,
+         casadi_taylor__8,
+         casadi_times__0,
+         casadi_times__1,
+         casadi_times__2,
+         casadi_times__3,
+         casadi_times__4,
+         casadi_trace__0,
+         casadi_trace__1,
+         casadi_trace__2,
+         casadi_trace__3,
+         casadi_transpose__0,
+         casadi_transpose__1,
+         casadi_transpose__2,
+         casadi_transpose__3,
+         casadi_transpose__4,
+         casadi_triangle__0,
+         casadi_triangle__1,
+         casadi_triangle__2,
+         casadi_tril2symm__0,
+         casadi_tril2symm__1,
+         casadi_tril2symm__2,
+         casadi_tril2symm__3,
+         casadi_tril__0,
+         casadi_tril__1,
+         casadi_tril__2,
+         casadi_tril__3,
+         casadi_tril__4,
+         casadi_tril__5,
+         casadi_tril__6,
+         casadi_tril__7,
+         casadi_tril__8,
+         casadi_tril__9,
+         casadi_triu2symm__0,
+         casadi_triu2symm__1,
+         casadi_triu2symm__2,
+         casadi_triu2symm__3,
+         casadi_triu__0,
+         casadi_triu__1,
+         casadi_triu__2,
+         casadi_triu__3,
+         casadi_triu__4,
+         casadi_triu__5,
+         casadi_triu__6,
+         casadi_triu__7,
+         casadi_triu__8,
+         casadi_triu__9,
+         casadi_unite__0,
+         casadi_unite__1,
+         casadi_unite__2,
+         casadi_unite__3,
+         casadi_vec__0,
+         casadi_vec__1,
+         casadi_vec__2,
+         casadi_vec__3,
+         casadi_vec__4,
+         casadi_veccat__0,
+         casadi_veccat__1,
+         casadi_veccat__2,
+         casadi_veccat__3,
+         casadi_veccat__4,
+         casadi_vertcat__0,
+         casadi_vertcat__1,
+         casadi_vertcat__2,
+         casadi_vertcat__3,
+         casadi_vertcat__4,
+         casadi_vertsplit__0,
+         casadi_vertsplit__1,
+         casadi_vertsplit__10,
+         casadi_vertsplit__11,
+         casadi_vertsplit__12,
+         casadi_vertsplit__13,
+         casadi_vertsplit__14,
+         casadi_vertsplit__2,
+         casadi_vertsplit__3,
+         casadi_vertsplit__4,
+         casadi_vertsplit__5,
+         casadi_vertsplit__6,
+         casadi_vertsplit__7,
+         casadi_vertsplit__8,
+         casadi_vertsplit__9,
+         collocationInterpolators,
+         collocation_points__0,
+         collocation_points__1,
+         complement,
+         doc_integrator,
+         doc_linsol,
+         doc_nlpsol,
+         doc_qpsol,
+         doc_rootfinder,
+         external__0,
+         external__1,
+         external__2,
+         external__3,
+         external__4,
+         external__5,
+         has_integrator,
+         has_linsol,
+         has_nlpsol,
+         has_qpsol,
+         has_rootfinder,
+         hash_combine,
+         hash_sparsity,
+         integrator__0,
+         integrator__1,
+         integrator__2,
+         integrator__3,
+         integrator__4,
+         integrator__5,
+         integrator__6,
+         integrator__7,
+         integrator_in__0,
+         integrator_in__1,
+         integrator_n_in,
+         integrator_n_out,
+         integrator_out__0,
+         integrator_out__1,
+         is_slice2,
+         is_slice__0,
+         is_slice__1,
+         is_slice__2,
+         is_slice__3,
+         jit__0,
+         jit__1,
+         linsol__0,
+         linsol__1,
+         linsol_in__0,
+         linsol_in__1,
+         linsol_n_in,
+         linsol_n_out,
+         linsol_out__0,
+         linsol_out__1,
+         load_integrator,
+         load_linsol,
+         load_nlpsol,
+         load_qpsol,
+         load_rootfinder,
+         lookupvector,
+         nlpsol__0,
+         nlpsol__1,
+         nlpsol__2,
+         nlpsol__3,
+         nlpsol__4,
+         nlpsol__5,
+         nlpsol__6,
+         nlpsol__7,
+         nlpsol__8,
+         nlpsol__9,
+         nlpsol_default_in__0,
+         nlpsol_default_in__1,
+         nlpsol_in__0,
+         nlpsol_in__1,
+         nlpsol_n_in,
+         nlpsol_n_out,
+         nlpsol_out__0,
+         nlpsol_out__1,
+         qpsol__0,
+         qpsol__1,
+         qpsol__2,
+         qpsol__3,
+         qpsol__4,
+         qpsol__5,
+         qpsol_in__0,
+         qpsol_in__1,
+         qpsol_n_in,
+         qpsol_n_out,
+         qpsol_out__0,
+         qpsol_out__1,
+         rootfinder__0,
+         rootfinder__1,
+         simpleIRK__0,
+         simpleIRK__1,
+         simpleIRK__2,
+         simpleIRK__3,
+         simpleIRK__4,
+         simpleIRK__5,
+         simpleIntegrator__0,
+         simpleIntegrator__1,
+         simpleIntegrator__2,
+         simpleRK__0,
+         simpleRK__1,
+         simpleRK__2,
+         to_slice2,
+         to_slice__0,
+         to_slice__1,
+         to_slice__2,
+         to_slice__3,
+       ) where
+
+
+import Data.Vector ( Vector )
+import qualified Data.Map as M
+import Foreign.C.Types
+import Foreign.Marshal ( new, free )
+import Foreign.Storable ( peek )
+import Foreign.Ptr ( Ptr, nullPtr )
+
+import Casadi.Core.Data
+import Casadi.Core.Enums
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdMap, StdVec, StdString, StdPair )
+import Casadi.Internal.Marshal ( Marshal(..) )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+foreign import ccall unsafe "casadi_abs__0" c_casadi_abs__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_abs__0
+  :: Double -> IO Double
+casadi_abs__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_abs__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_abs__1" c_casadi_abs__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_abs__1
+  :: SX -> IO SX
+casadi_abs__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_abs__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_abs__2" c_casadi_abs__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_abs__2
+  :: DM -> IO DM
+casadi_abs__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_abs__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_abs__3" c_casadi_abs__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_abs__3
+  :: IM -> IO IM
+casadi_abs__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_abs__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_abs__4" c_casadi_abs__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_abs__4
+  :: MX -> IO MX
+casadi_abs__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_abs__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acos__0" c_casadi_acos__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_acos__0
+  :: Double -> IO Double
+casadi_acos__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acos__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acos__1" c_casadi_acos__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_acos__1
+  :: SX -> IO SX
+casadi_acos__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acos__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acos__2" c_casadi_acos__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_acos__2
+  :: DM -> IO DM
+casadi_acos__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acos__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acos__3" c_casadi_acos__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_acos__3
+  :: IM -> IO IM
+casadi_acos__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acos__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acos__4" c_casadi_acos__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_acos__4
+  :: MX -> IO MX
+casadi_acos__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acos__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acosh__0" c_casadi_acosh__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_acosh__0
+  :: Double -> IO Double
+casadi_acosh__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acosh__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acosh__1" c_casadi_acosh__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_acosh__1
+  :: SX -> IO SX
+casadi_acosh__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acosh__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acosh__2" c_casadi_acosh__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_acosh__2
+  :: DM -> IO DM
+casadi_acosh__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acosh__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acosh__3" c_casadi_acosh__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_acosh__3
+  :: IM -> IO IM
+casadi_acosh__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acosh__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_acosh__4" c_casadi_acosh__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_acosh__4
+  :: MX -> IO MX
+casadi_acosh__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_acosh__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_adj__0" c_casadi_adj__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_adj__0
+  :: SX -> IO SX
+casadi_adj__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_adj__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_adj__1" c_casadi_adj__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_adj__1
+  :: DM -> IO DM
+casadi_adj__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_adj__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_adj__2" c_casadi_adj__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_adj__2
+  :: IM -> IO IM
+casadi_adj__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_adj__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_all__0" c_casadi_all__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_all__0
+  :: SX -> IO SX
+casadi_all__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_all__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_all__1" c_casadi_all__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_all__1
+  :: DM -> IO DM
+casadi_all__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_all__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_all__2" c_casadi_all__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_all__2
+  :: IM -> IO IM
+casadi_all__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_all__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_and__0" c_casadi_and__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_and__0
+  :: Double -> Double -> IO Double
+casadi_and__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_and__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_and__1" c_casadi_and__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_and__1
+  :: SX -> SX -> IO SX
+casadi_and__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_and__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_and__2" c_casadi_and__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_and__2
+  :: DM -> DM -> IO DM
+casadi_and__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_and__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_and__3" c_casadi_and__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_and__3
+  :: IM -> IM -> IO IM
+casadi_and__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_and__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_and__4" c_casadi_and__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_and__4
+  :: MX -> MX -> IO MX
+casadi_and__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_and__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_any__0" c_casadi_any__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_any__0
+  :: SX -> IO SX
+casadi_any__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_any__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_any__1" c_casadi_any__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_any__1
+  :: DM -> IO DM
+casadi_any__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_any__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_any__2" c_casadi_any__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_any__2
+  :: IM -> IO IM
+casadi_any__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_any__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asin__0" c_casadi_asin__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_asin__0
+  :: Double -> IO Double
+casadi_asin__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asin__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asin__1" c_casadi_asin__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_asin__1
+  :: SX -> IO SX
+casadi_asin__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asin__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asin__2" c_casadi_asin__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_asin__2
+  :: DM -> IO DM
+casadi_asin__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asin__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asin__3" c_casadi_asin__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_asin__3
+  :: IM -> IO IM
+casadi_asin__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asin__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asin__4" c_casadi_asin__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_asin__4
+  :: MX -> IO MX
+casadi_asin__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asin__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asinh__0" c_casadi_asinh__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_asinh__0
+  :: Double -> IO Double
+casadi_asinh__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asinh__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asinh__1" c_casadi_asinh__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_asinh__1
+  :: SX -> IO SX
+casadi_asinh__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asinh__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asinh__2" c_casadi_asinh__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_asinh__2
+  :: DM -> IO DM
+casadi_asinh__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asinh__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asinh__3" c_casadi_asinh__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_asinh__3
+  :: IM -> IO IM
+casadi_asinh__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asinh__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_asinh__4" c_casadi_asinh__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_asinh__4
+  :: MX -> IO MX
+casadi_asinh__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_asinh__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan__0" c_casadi_atan__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_atan__0
+  :: Double -> IO Double
+casadi_atan__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan__1" c_casadi_atan__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_atan__1
+  :: SX -> IO SX
+casadi_atan__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan__2" c_casadi_atan__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_atan__2
+  :: DM -> IO DM
+casadi_atan__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan__3" c_casadi_atan__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_atan__3
+  :: IM -> IO IM
+casadi_atan__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan__4" c_casadi_atan__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_atan__4
+  :: MX -> IO MX
+casadi_atan__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan2__0" c_casadi_atan2__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_atan2__0
+  :: Double -> Double -> IO Double
+casadi_atan2__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan2__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan2__1" c_casadi_atan2__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_atan2__1
+  :: SX -> SX -> IO SX
+casadi_atan2__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan2__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan2__2" c_casadi_atan2__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_atan2__2
+  :: DM -> DM -> IO DM
+casadi_atan2__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan2__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan2__3" c_casadi_atan2__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_atan2__3
+  :: IM -> IM -> IO IM
+casadi_atan2__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan2__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atan2__4" c_casadi_atan2__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_atan2__4
+  :: MX -> MX -> IO MX
+casadi_atan2__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atan2__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atanh__0" c_casadi_atanh__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_atanh__0
+  :: Double -> IO Double
+casadi_atanh__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atanh__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atanh__1" c_casadi_atanh__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_atanh__1
+  :: SX -> IO SX
+casadi_atanh__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atanh__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atanh__2" c_casadi_atanh__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_atanh__2
+  :: DM -> IO DM
+casadi_atanh__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atanh__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atanh__3" c_casadi_atanh__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_atanh__3
+  :: IM -> IO IM
+casadi_atanh__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atanh__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_atanh__4" c_casadi_atanh__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_atanh__4
+  :: MX -> IO MX
+casadi_atanh__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_atanh__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_bilin__0" c_casadi_bilin__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_bilin__0
+  :: SX -> SX -> SX -> IO SX
+casadi_bilin__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_bilin__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_bilin__1" c_casadi_bilin__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_bilin__1
+  :: DM -> DM -> DM -> IO DM
+casadi_bilin__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_bilin__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_bilin__2" c_casadi_bilin__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_bilin__2
+  :: IM -> IM -> IM -> IO IM
+casadi_bilin__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_bilin__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_bilin__3" c_casadi_bilin__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_bilin__3
+  :: MX -> MX -> MX -> IO MX
+casadi_bilin__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_bilin__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__0" c_casadi_blockcat__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_blockcat__0
+  :: SX -> SX -> SX -> SX -> IO SX
+casadi_blockcat__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__1" c_casadi_blockcat__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO (Ptr SX')
+
+casadi_blockcat__1
+  :: Vector (Vector SX) -> IO SX
+casadi_blockcat__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__2" c_casadi_blockcat__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_blockcat__2
+  :: DM -> DM -> DM -> DM -> IO DM
+casadi_blockcat__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__3" c_casadi_blockcat__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr DM')))) -> IO (Ptr DM')
+
+casadi_blockcat__3
+  :: Vector (Vector DM) -> IO DM
+casadi_blockcat__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__4" c_casadi_blockcat__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_blockcat__4
+  :: IM -> IM -> IM -> IM -> IO IM
+casadi_blockcat__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__5" c_casadi_blockcat__5
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IM')))) -> IO (Ptr IM')
+
+casadi_blockcat__5
+  :: Vector (Vector IM) -> IO IM
+casadi_blockcat__5 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__5 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__6" c_casadi_blockcat__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_blockcat__6
+  :: MX -> MX -> MX -> MX -> IO MX
+casadi_blockcat__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__7" c_casadi_blockcat__7
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr MX')
+
+casadi_blockcat__7
+  :: Vector (Vector MX) -> IO MX
+casadi_blockcat__7 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__7 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__8" c_casadi_blockcat__8
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_blockcat__8
+  :: Sparsity -> Sparsity -> Sparsity -> Sparsity -> IO Sparsity
+casadi_blockcat__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blockcat__9" c_casadi_blockcat__9
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr Sparsity')
+
+casadi_blockcat__9
+  :: Vector (Vector Sparsity) -> IO Sparsity
+casadi_blockcat__9 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blockcat__9 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__0" c_casadi_blocksplit__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+
+casadi_blocksplit__0
+  :: SX -> IO (Vector (Vector SX))
+casadi_blocksplit__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__1" c_casadi_blocksplit__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+
+casadi_blocksplit__1
+  :: SX -> Int -> IO (Vector (Vector SX))
+casadi_blocksplit__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__2" c_casadi_blocksplit__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+
+casadi_blocksplit__2
+  :: SX -> Int -> Int -> IO (Vector (Vector SX))
+casadi_blocksplit__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__3" c_casadi_blocksplit__3
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+
+casadi_blocksplit__3
+  :: SX -> Vector Int -> Vector Int -> IO (Vector (Vector SX))
+casadi_blocksplit__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__4" c_casadi_blocksplit__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DM')))))
+
+casadi_blocksplit__4
+  :: DM -> IO (Vector (Vector DM))
+casadi_blocksplit__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__5" c_casadi_blocksplit__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DM')))))
+
+casadi_blocksplit__5
+  :: DM -> Int -> IO (Vector (Vector DM))
+casadi_blocksplit__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__6" c_casadi_blocksplit__6
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DM')))))
+
+casadi_blocksplit__6
+  :: DM -> Int -> Int -> IO (Vector (Vector DM))
+casadi_blocksplit__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__7" c_casadi_blocksplit__7
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DM')))))
+
+casadi_blocksplit__7
+  :: DM -> Vector Int -> Vector Int -> IO (Vector (Vector DM))
+casadi_blocksplit__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__8" c_casadi_blocksplit__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IM')))))
+
+casadi_blocksplit__8
+  :: IM -> IO (Vector (Vector IM))
+casadi_blocksplit__8 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__8 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__9" c_casadi_blocksplit__9
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IM')))))
+
+casadi_blocksplit__9
+  :: IM -> Int -> IO (Vector (Vector IM))
+casadi_blocksplit__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__10" c_casadi_blocksplit__10
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IM')))))
+
+casadi_blocksplit__10
+  :: IM -> Int -> Int -> IO (Vector (Vector IM))
+casadi_blocksplit__10 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__10 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__11" c_casadi_blocksplit__11
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IM')))))
+
+casadi_blocksplit__11
+  :: IM -> Vector Int -> Vector Int -> IO (Vector (Vector IM))
+casadi_blocksplit__11 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__11 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__12" c_casadi_blocksplit__12
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+
+casadi_blocksplit__12
+  :: MX -> IO (Vector (Vector MX))
+casadi_blocksplit__12 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__12 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__13" c_casadi_blocksplit__13
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+
+casadi_blocksplit__13
+  :: MX -> Int -> IO (Vector (Vector MX))
+casadi_blocksplit__13 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__13 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__14" c_casadi_blocksplit__14
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+
+casadi_blocksplit__14
+  :: MX -> Int -> Int -> IO (Vector (Vector MX))
+casadi_blocksplit__14 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__14 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__15" c_casadi_blocksplit__15
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+
+casadi_blocksplit__15
+  :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX))
+casadi_blocksplit__15 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__15 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__16" c_casadi_blocksplit__16
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
+
+casadi_blocksplit__16
+  :: Sparsity -> IO (Vector (Vector Sparsity))
+casadi_blocksplit__16 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__16 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__17" c_casadi_blocksplit__17
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
+
+casadi_blocksplit__17
+  :: Sparsity -> Int -> IO (Vector (Vector Sparsity))
+casadi_blocksplit__17 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__17 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__18" c_casadi_blocksplit__18
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
+
+casadi_blocksplit__18
+  :: Sparsity -> Int -> Int -> IO (Vector (Vector Sparsity))
+casadi_blocksplit__18 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__18 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_blocksplit__19" c_casadi_blocksplit__19
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
+
+casadi_blocksplit__19
+  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector (Vector Sparsity))
+casadi_blocksplit__19 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_blocksplit__19 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ceil__0" c_casadi_ceil__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_ceil__0
+  :: Double -> IO Double
+casadi_ceil__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ceil__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ceil__1" c_casadi_ceil__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_ceil__1
+  :: SX -> IO SX
+casadi_ceil__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ceil__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ceil__2" c_casadi_ceil__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_ceil__2
+  :: DM -> IO DM
+casadi_ceil__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ceil__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ceil__3" c_casadi_ceil__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_ceil__3
+  :: IM -> IO IM
+casadi_ceil__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ceil__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ceil__4" c_casadi_ceil__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_ceil__4
+  :: MX -> IO MX
+casadi_ceil__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ceil__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_chol__0" c_casadi_chol__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_chol__0
+  :: SX -> IO SX
+casadi_chol__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_chol__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_chol__1" c_casadi_chol__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_chol__1
+  :: DM -> IO DM
+casadi_chol__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_chol__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_chol__2" c_casadi_chol__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_chol__2
+  :: IM -> IO IM
+casadi_chol__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_chol__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cofactor__0" c_casadi_cofactor__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi_cofactor__0
+  :: SX -> Int -> Int -> IO SX
+casadi_cofactor__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cofactor__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cofactor__1" c_casadi_cofactor__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi_cofactor__1
+  :: DM -> Int -> Int -> IO DM
+casadi_cofactor__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cofactor__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cofactor__2" c_casadi_cofactor__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi_cofactor__2
+  :: IM -> Int -> Int -> IO IM
+casadi_cofactor__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cofactor__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__0" c_casadi_conditional__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_conditional__0
+  :: SX -> Vector SX -> SX -> IO SX
+casadi_conditional__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__1" c_casadi_conditional__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_conditional__1
+  :: SX -> Vector SX -> SX -> Bool -> IO SX
+casadi_conditional__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__2" c_casadi_conditional__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec (Ptr DM')) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_conditional__2
+  :: DM -> Vector DM -> DM -> IO DM
+casadi_conditional__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__3" c_casadi_conditional__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec (Ptr DM')) -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_conditional__3
+  :: DM -> Vector DM -> DM -> Bool -> IO DM
+casadi_conditional__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__4" c_casadi_conditional__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec (Ptr IM')) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_conditional__4
+  :: IM -> Vector IM -> IM -> IO IM
+casadi_conditional__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__5" c_casadi_conditional__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec (Ptr IM')) -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_conditional__5
+  :: IM -> Vector IM -> IM -> Bool -> IO IM
+casadi_conditional__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__6" c_casadi_conditional__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_conditional__6
+  :: MX -> Vector MX -> MX -> IO MX
+casadi_conditional__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_conditional__7" c_casadi_conditional__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_conditional__7
+  :: MX -> Vector MX -> MX -> Bool -> IO MX
+casadi_conditional__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_conditional__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_constpow__0" c_casadi_constpow__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_constpow__0
+  :: Double -> Double -> IO Double
+casadi_constpow__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_constpow__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_constpow__1" c_casadi_constpow__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_constpow__1
+  :: SX -> SX -> IO SX
+casadi_constpow__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_constpow__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_constpow__2" c_casadi_constpow__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_constpow__2
+  :: DM -> DM -> IO DM
+casadi_constpow__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_constpow__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_constpow__3" c_casadi_constpow__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_constpow__3
+  :: IM -> IM -> IO IM
+casadi_constpow__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_constpow__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_constpow__4" c_casadi_constpow__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_constpow__4
+  :: MX -> MX -> IO MX
+casadi_constpow__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_constpow__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_copysign__0" c_casadi_copysign__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_copysign__0
+  :: Double -> Double -> IO Double
+casadi_copysign__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_copysign__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_copysign__1" c_casadi_copysign__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_copysign__1
+  :: SX -> SX -> IO SX
+casadi_copysign__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_copysign__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_copysign__2" c_casadi_copysign__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_copysign__2
+  :: DM -> DM -> IO DM
+casadi_copysign__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_copysign__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_copysign__3" c_casadi_copysign__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_copysign__3
+  :: IM -> IM -> IO IM
+casadi_copysign__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_copysign__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_copysign__4" c_casadi_copysign__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_copysign__4
+  :: MX -> MX -> IO MX
+casadi_copysign__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_copysign__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cos__0" c_casadi_cos__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_cos__0
+  :: Double -> IO Double
+casadi_cos__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cos__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cos__1" c_casadi_cos__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_cos__1
+  :: SX -> IO SX
+casadi_cos__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cos__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cos__2" c_casadi_cos__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_cos__2
+  :: DM -> IO DM
+casadi_cos__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cos__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cos__3" c_casadi_cos__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_cos__3
+  :: IM -> IO IM
+casadi_cos__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cos__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cos__4" c_casadi_cos__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_cos__4
+  :: MX -> IO MX
+casadi_cos__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cos__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cosh__0" c_casadi_cosh__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_cosh__0
+  :: Double -> IO Double
+casadi_cosh__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cosh__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cosh__1" c_casadi_cosh__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_cosh__1
+  :: SX -> IO SX
+casadi_cosh__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cosh__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cosh__2" c_casadi_cosh__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_cosh__2
+  :: DM -> IO DM
+casadi_cosh__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cosh__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cosh__3" c_casadi_cosh__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_cosh__3
+  :: IM -> IO IM
+casadi_cosh__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cosh__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cosh__4" c_casadi_cosh__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_cosh__4
+  :: MX -> IO MX
+casadi_cosh__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cosh__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__0" c_casadi_cross__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_cross__0
+  :: SX -> SX -> IO SX
+casadi_cross__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__1" c_casadi_cross__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_cross__1
+  :: SX -> SX -> Int -> IO SX
+casadi_cross__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__2" c_casadi_cross__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_cross__2
+  :: DM -> DM -> IO DM
+casadi_cross__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__3" c_casadi_cross__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_cross__3
+  :: DM -> DM -> Int -> IO DM
+casadi_cross__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__4" c_casadi_cross__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_cross__4
+  :: IM -> IM -> IO IM
+casadi_cross__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__5" c_casadi_cross__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_cross__5
+  :: IM -> IM -> Int -> IO IM
+casadi_cross__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__6" c_casadi_cross__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_cross__6
+  :: MX -> MX -> IO MX
+casadi_cross__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_cross__7" c_casadi_cross__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_cross__7
+  :: MX -> MX -> Int -> IO MX
+casadi_cross__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_cross__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_densify__0" c_casadi_densify__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_densify__0
+  :: SX -> IO SX
+casadi_densify__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_densify__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_densify__1" c_casadi_densify__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_densify__1
+  :: DM -> IO DM
+casadi_densify__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_densify__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_densify__2" c_casadi_densify__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_densify__2
+  :: IM -> IO IM
+casadi_densify__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_densify__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_densify__3" c_casadi_densify__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_densify__3
+  :: MX -> IO MX
+casadi_densify__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_densify__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_depends_on__0" c_casadi_depends_on__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
+
+casadi_depends_on__0
+  :: SX -> SX -> IO Bool
+casadi_depends_on__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_depends_on__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_depends_on__1" c_casadi_depends_on__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO CInt
+
+casadi_depends_on__1
+  :: DM -> DM -> IO Bool
+casadi_depends_on__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_depends_on__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_depends_on__2" c_casadi_depends_on__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO CInt
+
+casadi_depends_on__2
+  :: IM -> IM -> IO Bool
+casadi_depends_on__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_depends_on__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_depends_on__3" c_casadi_depends_on__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
+
+casadi_depends_on__3
+  :: MX -> MX -> IO Bool
+casadi_depends_on__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_depends_on__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_det__0" c_casadi_det__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_det__0
+  :: SX -> IO SX
+casadi_det__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_det__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_det__1" c_casadi_det__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_det__1
+  :: DM -> IO DM
+casadi_det__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_det__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_det__2" c_casadi_det__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_det__2
+  :: IM -> IO IM
+casadi_det__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_det__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_det__3" c_casadi_det__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_det__3
+  :: MX -> IO MX
+casadi_det__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_det__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diag__0" c_casadi_diag__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_diag__0
+  :: SX -> IO SX
+casadi_diag__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diag__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diag__1" c_casadi_diag__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_diag__1
+  :: DM -> IO DM
+casadi_diag__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diag__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diag__2" c_casadi_diag__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_diag__2
+  :: IM -> IO IM
+casadi_diag__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diag__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diag__3" c_casadi_diag__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_diag__3
+  :: MX -> IO MX
+casadi_diag__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diag__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagcat__0" c_casadi_diagcat__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+
+casadi_diagcat__0
+  :: Vector SX -> IO SX
+casadi_diagcat__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagcat__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagcat__1" c_casadi_diagcat__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> IO (Ptr DM')
+
+casadi_diagcat__1
+  :: Vector DM -> IO DM
+casadi_diagcat__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagcat__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagcat__2" c_casadi_diagcat__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> IO (Ptr IM')
+
+casadi_diagcat__2
+  :: Vector IM -> IO IM
+casadi_diagcat__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagcat__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagcat__3" c_casadi_diagcat__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi_diagcat__3
+  :: Vector MX -> IO MX
+casadi_diagcat__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagcat__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagcat__4" c_casadi_diagcat__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+
+casadi_diagcat__4
+  :: Vector Sparsity -> IO Sparsity
+casadi_diagcat__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagcat__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__0" c_casadi_diagsplit__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_diagsplit__0
+  :: SX -> Int -> Int -> IO (Vector SX)
+casadi_diagsplit__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__1" c_casadi_diagsplit__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_diagsplit__1
+  :: SX -> IO (Vector SX)
+casadi_diagsplit__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__2" c_casadi_diagsplit__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_diagsplit__2
+  :: SX -> Int -> IO (Vector SX)
+casadi_diagsplit__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__3" c_casadi_diagsplit__3
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_diagsplit__3
+  :: SX -> Vector Int -> IO (Vector SX)
+casadi_diagsplit__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__4" c_casadi_diagsplit__4
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_diagsplit__4
+  :: SX -> Vector Int -> Vector Int -> IO (Vector SX)
+casadi_diagsplit__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__5" c_casadi_diagsplit__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_diagsplit__5
+  :: DM -> Int -> Int -> IO (Vector DM)
+casadi_diagsplit__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__6" c_casadi_diagsplit__6
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_diagsplit__6
+  :: DM -> IO (Vector DM)
+casadi_diagsplit__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__7" c_casadi_diagsplit__7
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_diagsplit__7
+  :: DM -> Int -> IO (Vector DM)
+casadi_diagsplit__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__8" c_casadi_diagsplit__8
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_diagsplit__8
+  :: DM -> Vector Int -> IO (Vector DM)
+casadi_diagsplit__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__9" c_casadi_diagsplit__9
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_diagsplit__9
+  :: DM -> Vector Int -> Vector Int -> IO (Vector DM)
+casadi_diagsplit__9 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__9 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__10" c_casadi_diagsplit__10
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_diagsplit__10
+  :: IM -> Int -> Int -> IO (Vector IM)
+casadi_diagsplit__10 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__10 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__11" c_casadi_diagsplit__11
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_diagsplit__11
+  :: IM -> IO (Vector IM)
+casadi_diagsplit__11 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__11 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__12" c_casadi_diagsplit__12
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_diagsplit__12
+  :: IM -> Int -> IO (Vector IM)
+casadi_diagsplit__12 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__12 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__13" c_casadi_diagsplit__13
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_diagsplit__13
+  :: IM -> Vector Int -> IO (Vector IM)
+casadi_diagsplit__13 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__13 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__14" c_casadi_diagsplit__14
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_diagsplit__14
+  :: IM -> Vector Int -> Vector Int -> IO (Vector IM)
+casadi_diagsplit__14 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__14 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__15" c_casadi_diagsplit__15
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_diagsplit__15
+  :: MX -> Int -> Int -> IO (Vector MX)
+casadi_diagsplit__15 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__15 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__16" c_casadi_diagsplit__16
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_diagsplit__16
+  :: MX -> IO (Vector MX)
+casadi_diagsplit__16 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__16 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__17" c_casadi_diagsplit__17
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_diagsplit__17
+  :: MX -> Int -> IO (Vector MX)
+casadi_diagsplit__17 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__17 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__18" c_casadi_diagsplit__18
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_diagsplit__18
+  :: MX -> Vector Int -> IO (Vector MX)
+casadi_diagsplit__18 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__18 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__19" c_casadi_diagsplit__19
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_diagsplit__19
+  :: MX -> Vector Int -> Vector Int -> IO (Vector MX)
+casadi_diagsplit__19 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__19 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__20" c_casadi_diagsplit__20
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_diagsplit__20
+  :: Sparsity -> Int -> Int -> IO (Vector Sparsity)
+casadi_diagsplit__20 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__20 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__21" c_casadi_diagsplit__21
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_diagsplit__21
+  :: Sparsity -> IO (Vector Sparsity)
+casadi_diagsplit__21 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__21 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__22" c_casadi_diagsplit__22
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_diagsplit__22
+  :: Sparsity -> Int -> IO (Vector Sparsity)
+casadi_diagsplit__22 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__22 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__23" c_casadi_diagsplit__23
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_diagsplit__23
+  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
+casadi_diagsplit__23 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__23 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_diagsplit__24" c_casadi_diagsplit__24
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_diagsplit__24
+  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Sparsity)
+casadi_diagsplit__24 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_diagsplit__24 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_dot__0" c_casadi_dot__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_dot__0
+  :: SX -> SX -> IO SX
+casadi_dot__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_dot__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_dot__1" c_casadi_dot__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_dot__1
+  :: DM -> DM -> IO DM
+casadi_dot__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_dot__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_dot__2" c_casadi_dot__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_dot__2
+  :: IM -> IM -> IO IM
+casadi_dot__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_dot__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_dot__3" c_casadi_dot__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_dot__3
+  :: MX -> MX -> IO MX
+casadi_dot__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_dot__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eig_symbolic__0" c_casadi_eig_symbolic__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_eig_symbolic__0
+  :: SX -> IO SX
+casadi_eig_symbolic__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eig_symbolic__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eig_symbolic__1" c_casadi_eig_symbolic__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_eig_symbolic__1
+  :: DM -> IO DM
+casadi_eig_symbolic__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eig_symbolic__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eig_symbolic__2" c_casadi_eig_symbolic__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_eig_symbolic__2
+  :: IM -> IO IM
+casadi_eig_symbolic__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eig_symbolic__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eq__0" c_casadi_eq__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_eq__0
+  :: Double -> Double -> IO Double
+casadi_eq__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eq__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eq__1" c_casadi_eq__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_eq__1
+  :: SX -> SX -> IO SX
+casadi_eq__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eq__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eq__2" c_casadi_eq__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_eq__2
+  :: DM -> DM -> IO DM
+casadi_eq__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eq__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eq__3" c_casadi_eq__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_eq__3
+  :: IM -> IM -> IO IM
+casadi_eq__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eq__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_eq__4" c_casadi_eq__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_eq__4
+  :: MX -> MX -> IO MX
+casadi_eq__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_eq__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erf__0" c_casadi_erf__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_erf__0
+  :: Double -> IO Double
+casadi_erf__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erf__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erf__1" c_casadi_erf__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_erf__1
+  :: SX -> IO SX
+casadi_erf__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erf__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erf__2" c_casadi_erf__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_erf__2
+  :: DM -> IO DM
+casadi_erf__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erf__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erf__3" c_casadi_erf__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_erf__3
+  :: IM -> IO IM
+casadi_erf__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erf__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erf__4" c_casadi_erf__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_erf__4
+  :: MX -> IO MX
+casadi_erf__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erf__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erfinv__0" c_casadi_erfinv__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_erfinv__0
+  :: Double -> IO Double
+casadi_erfinv__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erfinv__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erfinv__1" c_casadi_erfinv__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_erfinv__1
+  :: SX -> IO SX
+casadi_erfinv__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erfinv__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erfinv__2" c_casadi_erfinv__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_erfinv__2
+  :: DM -> IO DM
+casadi_erfinv__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erfinv__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erfinv__3" c_casadi_erfinv__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_erfinv__3
+  :: IM -> IO IM
+casadi_erfinv__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erfinv__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_erfinv__4" c_casadi_erfinv__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_erfinv__4
+  :: MX -> IO MX
+casadi_erfinv__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_erfinv__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_exp__0" c_casadi_exp__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_exp__0
+  :: Double -> IO Double
+casadi_exp__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_exp__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_exp__1" c_casadi_exp__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_exp__1
+  :: SX -> IO SX
+casadi_exp__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_exp__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_exp__2" c_casadi_exp__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_exp__2
+  :: DM -> IO DM
+casadi_exp__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_exp__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_exp__3" c_casadi_exp__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_exp__3
+  :: IM -> IO IM
+casadi_exp__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_exp__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_exp__4" c_casadi_exp__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_exp__4
+  :: MX -> IO MX
+casadi_exp__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_exp__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_expand__0" c_casadi_expand__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
+
+casadi_expand__0
+  :: SX -> SX -> SX -> IO ()
+casadi_expand__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_expand__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_expand__1" c_casadi_expand__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO ()
+
+casadi_expand__1
+  :: DM -> DM -> DM -> IO ()
+casadi_expand__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_expand__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_expand__2" c_casadi_expand__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi_expand__2
+  :: IM -> IM -> IM -> IO ()
+casadi_expand__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_expand__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_find" c_casadi_find
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_find
+  :: MX -> IO MX
+casadi_find x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_find errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_floor__0" c_casadi_floor__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_floor__0
+  :: Double -> IO Double
+casadi_floor__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_floor__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_floor__1" c_casadi_floor__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_floor__1
+  :: SX -> IO SX
+casadi_floor__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_floor__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_floor__2" c_casadi_floor__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_floor__2
+  :: DM -> IO DM
+casadi_floor__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_floor__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_floor__3" c_casadi_floor__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_floor__3
+  :: IM -> IO IM
+casadi_floor__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_floor__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_floor__4" c_casadi_floor__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_floor__4
+  :: MX -> IO MX
+casadi_floor__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_floor__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__0" c_casadi_gauss_quadrature__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr SX' -> IO (Ptr SX')
+
+casadi_gauss_quadrature__0
+  :: SX -> SX -> SX -> SX -> Int -> SX -> IO SX
+casadi_gauss_quadrature__0 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__1" c_casadi_gauss_quadrature__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_gauss_quadrature__1
+  :: SX -> SX -> SX -> SX -> IO SX
+casadi_gauss_quadrature__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__2" c_casadi_gauss_quadrature__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_gauss_quadrature__2
+  :: SX -> SX -> SX -> SX -> Int -> IO SX
+casadi_gauss_quadrature__2 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__3" c_casadi_gauss_quadrature__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> Ptr DM' -> CInt -> Ptr DM' -> IO (Ptr DM')
+
+casadi_gauss_quadrature__3
+  :: DM -> DM -> DM -> DM -> Int -> DM -> IO DM
+casadi_gauss_quadrature__3 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__3 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__4" c_casadi_gauss_quadrature__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_gauss_quadrature__4
+  :: DM -> DM -> DM -> DM -> IO DM
+casadi_gauss_quadrature__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__5" c_casadi_gauss_quadrature__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_gauss_quadrature__5
+  :: DM -> DM -> DM -> DM -> Int -> IO DM
+casadi_gauss_quadrature__5 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__5 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__6" c_casadi_gauss_quadrature__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> Ptr IM' -> CInt -> Ptr IM' -> IO (Ptr IM')
+
+casadi_gauss_quadrature__6
+  :: IM -> IM -> IM -> IM -> Int -> IM -> IO IM
+casadi_gauss_quadrature__6 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__6 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__7" c_casadi_gauss_quadrature__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_gauss_quadrature__7
+  :: IM -> IM -> IM -> IM -> IO IM
+casadi_gauss_quadrature__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gauss_quadrature__8" c_casadi_gauss_quadrature__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_gauss_quadrature__8
+  :: IM -> IM -> IM -> IM -> Int -> IO IM
+casadi_gauss_quadrature__8 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gauss_quadrature__8 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ge__0" c_casadi_ge__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_ge__0
+  :: Double -> Double -> IO Double
+casadi_ge__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ge__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ge__1" c_casadi_ge__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_ge__1
+  :: SX -> SX -> IO SX
+casadi_ge__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ge__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ge__2" c_casadi_ge__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_ge__2
+  :: DM -> DM -> IO DM
+casadi_ge__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ge__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ge__3" c_casadi_ge__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_ge__3
+  :: IM -> IM -> IO IM
+casadi_ge__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ge__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ge__4" c_casadi_ge__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_ge__4
+  :: MX -> MX -> IO MX
+casadi_ge__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ge__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_getMinor__0" c_casadi_getMinor__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi_getMinor__0
+  :: SX -> Int -> Int -> IO SX
+casadi_getMinor__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_getMinor__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_getMinor__1" c_casadi_getMinor__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi_getMinor__1
+  :: DM -> Int -> Int -> IO DM
+casadi_getMinor__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_getMinor__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_getMinor__2" c_casadi_getMinor__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi_getMinor__2
+  :: IM -> Int -> Int -> IO IM
+casadi_getMinor__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_getMinor__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gradient__0" c_casadi_gradient__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_gradient__0
+  :: SX -> SX -> IO SX
+casadi_gradient__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gradient__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gradient__1" c_casadi_gradient__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_gradient__1
+  :: DM -> DM -> IO DM
+casadi_gradient__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gradient__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gradient__2" c_casadi_gradient__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_gradient__2
+  :: IM -> IM -> IO IM
+casadi_gradient__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gradient__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gradient__3" c_casadi_gradient__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_gradient__3
+  :: MX -> MX -> IO MX
+casadi_gradient__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gradient__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_graph_substitute__0" c_casadi_graph_substitute__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_graph_substitute__0
+  :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
+casadi_graph_substitute__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_graph_substitute__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_graph_substitute__1" c_casadi_graph_substitute__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi_graph_substitute__1
+  :: MX -> Vector MX -> Vector MX -> IO MX
+casadi_graph_substitute__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_graph_substitute__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gt__0" c_casadi_gt__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_gt__0
+  :: Double -> Double -> IO Double
+casadi_gt__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gt__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gt__1" c_casadi_gt__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_gt__1
+  :: SX -> SX -> IO SX
+casadi_gt__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gt__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gt__2" c_casadi_gt__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_gt__2
+  :: DM -> DM -> IO DM
+casadi_gt__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gt__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gt__3" c_casadi_gt__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_gt__3
+  :: IM -> IM -> IO IM
+casadi_gt__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gt__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_gt__4" c_casadi_gt__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_gt__4
+  :: MX -> MX -> IO MX
+casadi_gt__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_gt__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_heaviside__0" c_casadi_heaviside__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_heaviside__0
+  :: SX -> IO SX
+casadi_heaviside__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_heaviside__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_heaviside__1" c_casadi_heaviside__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_heaviside__1
+  :: DM -> IO DM
+casadi_heaviside__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_heaviside__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_heaviside__2" c_casadi_heaviside__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_heaviside__2
+  :: IM -> IO IM
+casadi_heaviside__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_heaviside__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_hessian__0" c_casadi_hessian__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_hessian__0
+  :: SX -> SX -> SX -> IO SX
+casadi_hessian__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_hessian__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_hessian__1" c_casadi_hessian__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_hessian__1
+  :: DM -> DM -> DM -> IO DM
+casadi_hessian__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_hessian__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_hessian__2" c_casadi_hessian__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_hessian__2
+  :: IM -> IM -> IM -> IO IM
+casadi_hessian__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_hessian__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_hessian__3" c_casadi_hessian__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_hessian__3
+  :: MX -> MX -> MX -> IO MX
+casadi_hessian__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_hessian__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzcat__0" c_casadi_horzcat__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+
+casadi_horzcat__0
+  :: Vector SX -> IO SX
+casadi_horzcat__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzcat__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzcat__1" c_casadi_horzcat__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> IO (Ptr DM')
+
+casadi_horzcat__1
+  :: Vector DM -> IO DM
+casadi_horzcat__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzcat__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzcat__2" c_casadi_horzcat__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> IO (Ptr IM')
+
+casadi_horzcat__2
+  :: Vector IM -> IO IM
+casadi_horzcat__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzcat__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzcat__3" c_casadi_horzcat__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi_horzcat__3
+  :: Vector MX -> IO MX
+casadi_horzcat__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzcat__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzcat__4" c_casadi_horzcat__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+
+casadi_horzcat__4
+  :: Vector Sparsity -> IO Sparsity
+casadi_horzcat__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzcat__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__0" c_casadi_horzsplit__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_horzsplit__0
+  :: SX -> IO (Vector SX)
+casadi_horzsplit__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__1" c_casadi_horzsplit__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_horzsplit__1
+  :: SX -> Int -> IO (Vector SX)
+casadi_horzsplit__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__2" c_casadi_horzsplit__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_horzsplit__2
+  :: SX -> Vector Int -> IO (Vector SX)
+casadi_horzsplit__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__3" c_casadi_horzsplit__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_horzsplit__3
+  :: DM -> IO (Vector DM)
+casadi_horzsplit__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__4" c_casadi_horzsplit__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_horzsplit__4
+  :: DM -> Int -> IO (Vector DM)
+casadi_horzsplit__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__5" c_casadi_horzsplit__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_horzsplit__5
+  :: DM -> Vector Int -> IO (Vector DM)
+casadi_horzsplit__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__6" c_casadi_horzsplit__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_horzsplit__6
+  :: IM -> IO (Vector IM)
+casadi_horzsplit__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__7" c_casadi_horzsplit__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_horzsplit__7
+  :: IM -> Int -> IO (Vector IM)
+casadi_horzsplit__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__8" c_casadi_horzsplit__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_horzsplit__8
+  :: IM -> Vector Int -> IO (Vector IM)
+casadi_horzsplit__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__9" c_casadi_horzsplit__9
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_horzsplit__9
+  :: MX -> IO (Vector MX)
+casadi_horzsplit__9 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__9 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__10" c_casadi_horzsplit__10
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_horzsplit__10
+  :: MX -> Int -> IO (Vector MX)
+casadi_horzsplit__10 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__10 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__11" c_casadi_horzsplit__11
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_horzsplit__11
+  :: MX -> Vector Int -> IO (Vector MX)
+casadi_horzsplit__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__12" c_casadi_horzsplit__12
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_horzsplit__12
+  :: Sparsity -> IO (Vector Sparsity)
+casadi_horzsplit__12 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__12 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__13" c_casadi_horzsplit__13
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_horzsplit__13
+  :: Sparsity -> Int -> IO (Vector Sparsity)
+casadi_horzsplit__13 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__13 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_horzsplit__14" c_casadi_horzsplit__14
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_horzsplit__14
+  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
+casadi_horzsplit__14 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_horzsplit__14 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__0" c_casadi_if_else__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_if_else__0
+  :: SX -> SX -> SX -> IO SX
+casadi_if_else__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__1" c_casadi_if_else__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_if_else__1
+  :: SX -> SX -> SX -> Bool -> IO SX
+casadi_if_else__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__2" c_casadi_if_else__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_if_else__2
+  :: DM -> DM -> DM -> IO DM
+casadi_if_else__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__3" c_casadi_if_else__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_if_else__3
+  :: DM -> DM -> DM -> Bool -> IO DM
+casadi_if_else__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__4" c_casadi_if_else__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_if_else__4
+  :: IM -> IM -> IM -> IO IM
+casadi_if_else__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__5" c_casadi_if_else__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_if_else__5
+  :: IM -> IM -> IM -> Bool -> IO IM
+casadi_if_else__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__6" c_casadi_if_else__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_if_else__6
+  :: MX -> MX -> MX -> IO MX
+casadi_if_else__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_if_else__7" c_casadi_if_else__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_if_else__7
+  :: MX -> MX -> MX -> Bool -> IO MX
+casadi_if_else__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_if_else__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv__0" c_casadi_inv__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_inv__0
+  :: SX -> IO SX
+casadi_inv__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv__1" c_casadi_inv__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_inv__1
+  :: DM -> IO DM
+casadi_inv__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv__2" c_casadi_inv__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_inv__2
+  :: IM -> IO IM
+casadi_inv__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv__3" c_casadi_inv__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_inv__3
+  :: MX -> IO MX
+casadi_inv__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv_skew__0" c_casadi_inv_skew__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_inv_skew__0
+  :: SX -> IO SX
+casadi_inv_skew__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv_skew__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv_skew__1" c_casadi_inv_skew__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_inv_skew__1
+  :: DM -> IO DM
+casadi_inv_skew__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv_skew__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv_skew__2" c_casadi_inv_skew__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_inv_skew__2
+  :: IM -> IO IM
+casadi_inv_skew__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv_skew__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_inv_skew__3" c_casadi_inv_skew__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_inv_skew__3
+  :: MX -> IO MX
+casadi_inv_skew__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_inv_skew__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__0" c_casadi_is_equal__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CInt
+
+casadi_is_equal__0
+  :: Double -> Double -> IO Bool
+casadi_is_equal__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__1" c_casadi_is_equal__1
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> CInt -> IO CInt
+
+casadi_is_equal__1
+  :: Double -> Double -> Int -> IO Bool
+casadi_is_equal__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__2" c_casadi_is_equal__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
+
+casadi_is_equal__2
+  :: SX -> SX -> IO Bool
+casadi_is_equal__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__3" c_casadi_is_equal__3
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO CInt
+
+casadi_is_equal__3
+  :: SX -> SX -> Int -> IO Bool
+casadi_is_equal__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__4" c_casadi_is_equal__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO CInt
+
+casadi_is_equal__4
+  :: DM -> DM -> IO Bool
+casadi_is_equal__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__5" c_casadi_is_equal__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> IO CInt
+
+casadi_is_equal__5
+  :: DM -> DM -> Int -> IO Bool
+casadi_is_equal__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__6" c_casadi_is_equal__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO CInt
+
+casadi_is_equal__6
+  :: IM -> IM -> IO Bool
+casadi_is_equal__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__7" c_casadi_is_equal__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> IO CInt
+
+casadi_is_equal__7
+  :: IM -> IM -> Int -> IO Bool
+casadi_is_equal__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__8" c_casadi_is_equal__8
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
+
+casadi_is_equal__8
+  :: MX -> MX -> IO Bool
+casadi_is_equal__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_is_equal__9" c_casadi_is_equal__9
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO CInt
+
+casadi_is_equal__9
+  :: MX -> MX -> Int -> IO Bool
+casadi_is_equal__9 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_is_equal__9 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jacobian__0" c_casadi_jacobian__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_jacobian__0
+  :: SX -> SX -> IO SX
+casadi_jacobian__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jacobian__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jacobian__1" c_casadi_jacobian__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_jacobian__1
+  :: DM -> DM -> IO DM
+casadi_jacobian__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jacobian__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jacobian__2" c_casadi_jacobian__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_jacobian__2
+  :: IM -> IM -> IO IM
+casadi_jacobian__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jacobian__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jacobian__3" c_casadi_jacobian__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_jacobian__3
+  :: MX -> MX -> IO MX
+casadi_jacobian__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jacobian__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__0" c_casadi_jtimes__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_jtimes__0
+  :: SX -> SX -> SX -> IO SX
+casadi_jtimes__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__1" c_casadi_jtimes__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_jtimes__1
+  :: SX -> SX -> SX -> Bool -> IO SX
+casadi_jtimes__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__2" c_casadi_jtimes__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_jtimes__2
+  :: DM -> DM -> DM -> IO DM
+casadi_jtimes__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__3" c_casadi_jtimes__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_jtimes__3
+  :: DM -> DM -> DM -> Bool -> IO DM
+casadi_jtimes__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__4" c_casadi_jtimes__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_jtimes__4
+  :: IM -> IM -> IM -> IO IM
+casadi_jtimes__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__5" c_casadi_jtimes__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_jtimes__5
+  :: IM -> IM -> IM -> Bool -> IO IM
+casadi_jtimes__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__6" c_casadi_jtimes__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_jtimes__6
+  :: MX -> MX -> MX -> IO MX
+casadi_jtimes__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_jtimes__7" c_casadi_jtimes__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_jtimes__7
+  :: MX -> MX -> MX -> Bool -> IO MX
+casadi_jtimes__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_jtimes__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_kron__0" c_casadi_kron__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_kron__0
+  :: SX -> SX -> IO SX
+casadi_kron__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_kron__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_kron__1" c_casadi_kron__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_kron__1
+  :: DM -> DM -> IO DM
+casadi_kron__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_kron__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_kron__2" c_casadi_kron__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_kron__2
+  :: IM -> IM -> IO IM
+casadi_kron__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_kron__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_kron__3" c_casadi_kron__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_kron__3
+  :: MX -> MX -> IO MX
+casadi_kron__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_kron__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_kron__4" c_casadi_kron__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_kron__4
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi_kron__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_kron__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ldivide__0" c_casadi_ldivide__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_ldivide__0
+  :: Double -> Double -> IO Double
+casadi_ldivide__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ldivide__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ldivide__1" c_casadi_ldivide__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_ldivide__1
+  :: SX -> SX -> IO SX
+casadi_ldivide__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ldivide__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ldivide__2" c_casadi_ldivide__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_ldivide__2
+  :: DM -> DM -> IO DM
+casadi_ldivide__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ldivide__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ldivide__3" c_casadi_ldivide__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_ldivide__3
+  :: IM -> IM -> IO IM
+casadi_ldivide__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ldivide__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ldivide__4" c_casadi_ldivide__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_ldivide__4
+  :: MX -> MX -> IO MX
+casadi_ldivide__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ldivide__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_le__0" c_casadi_le__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_le__0
+  :: Double -> Double -> IO Double
+casadi_le__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_le__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_le__1" c_casadi_le__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_le__1
+  :: SX -> SX -> IO SX
+casadi_le__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_le__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_le__2" c_casadi_le__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_le__2
+  :: DM -> DM -> IO DM
+casadi_le__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_le__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_le__3" c_casadi_le__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_le__3
+  :: IM -> IM -> IO IM
+casadi_le__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_le__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_le__4" c_casadi_le__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_le__4
+  :: MX -> MX -> IO MX
+casadi_le__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_le__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_linspace__0" c_casadi_linspace__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_linspace__0
+  :: SX -> SX -> Int -> IO SX
+casadi_linspace__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_linspace__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_linspace__1" c_casadi_linspace__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_linspace__1
+  :: DM -> DM -> Int -> IO DM
+casadi_linspace__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_linspace__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_linspace__2" c_casadi_linspace__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_linspace__2
+  :: IM -> IM -> Int -> IO IM
+casadi_linspace__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_linspace__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_linspace__3" c_casadi_linspace__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_linspace__3
+  :: MX -> MX -> Int -> IO MX
+casadi_linspace__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_linspace__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log__0" c_casadi_log__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_log__0
+  :: Double -> IO Double
+casadi_log__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log__1" c_casadi_log__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_log__1
+  :: SX -> IO SX
+casadi_log__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log__2" c_casadi_log__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_log__2
+  :: DM -> IO DM
+casadi_log__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log__3" c_casadi_log__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_log__3
+  :: IM -> IO IM
+casadi_log__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log__4" c_casadi_log__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_log__4
+  :: MX -> IO MX
+casadi_log__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log10__0" c_casadi_log10__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_log10__0
+  :: Double -> IO Double
+casadi_log10__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log10__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log10__1" c_casadi_log10__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_log10__1
+  :: SX -> IO SX
+casadi_log10__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log10__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log10__2" c_casadi_log10__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_log10__2
+  :: DM -> IO DM
+casadi_log10__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log10__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log10__3" c_casadi_log10__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_log10__3
+  :: IM -> IO IM
+casadi_log10__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log10__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_log10__4" c_casadi_log10__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_log10__4
+  :: MX -> IO MX
+casadi_log10__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_log10__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_lt__0" c_casadi_lt__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_lt__0
+  :: Double -> Double -> IO Double
+casadi_lt__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_lt__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_lt__1" c_casadi_lt__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_lt__1
+  :: SX -> SX -> IO SX
+casadi_lt__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_lt__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_lt__2" c_casadi_lt__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_lt__2
+  :: DM -> DM -> IO DM
+casadi_lt__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_lt__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_lt__3" c_casadi_lt__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_lt__3
+  :: IM -> IM -> IO IM
+casadi_lt__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_lt__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_lt__4" c_casadi_lt__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_lt__4
+  :: MX -> MX -> IO MX
+casadi_lt__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_lt__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mac__0" c_casadi_mac__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_mac__0
+  :: SX -> SX -> SX -> IO SX
+casadi_mac__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mac__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mac__1" c_casadi_mac__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_mac__1
+  :: DM -> DM -> DM -> IO DM
+casadi_mac__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mac__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mac__2" c_casadi_mac__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_mac__2
+  :: IM -> IM -> IM -> IO IM
+casadi_mac__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mac__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mac__3" c_casadi_mac__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_mac__3
+  :: MX -> MX -> MX -> IO MX
+casadi_mac__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mac__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mac__4" c_casadi_mac__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_mac__4
+  :: Sparsity -> Sparsity -> Sparsity -> IO Sparsity
+casadi_mac__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mac__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_matrix_expand__0" c_casadi_matrix_expand__0
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_matrix_expand__0
+  :: MX -> IO MX
+casadi_matrix_expand__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_matrix_expand__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_matrix_expand__1" c_casadi_matrix_expand__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi_matrix_expand__1
+  :: MX -> Vector MX -> IO MX
+casadi_matrix_expand__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_matrix_expand__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_matrix_expand__2" c_casadi_matrix_expand__2
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX')
+
+casadi_matrix_expand__2
+  :: MX -> Vector MX -> M.Map String GenericType -> IO MX
+casadi_matrix_expand__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_matrix_expand__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_matrix_expand__3" c_casadi_matrix_expand__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_matrix_expand__3
+  :: Vector MX -> IO (Vector MX)
+casadi_matrix_expand__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_matrix_expand__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_matrix_expand__4" c_casadi_matrix_expand__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_matrix_expand__4
+  :: Vector MX -> Vector MX -> IO (Vector MX)
+casadi_matrix_expand__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_matrix_expand__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_matrix_expand__5" c_casadi_matrix_expand__5
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_matrix_expand__5
+  :: Vector MX -> Vector MX -> M.Map String GenericType -> IO (Vector MX)
+casadi_matrix_expand__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_matrix_expand__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_max__0" c_casadi_max__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_max__0
+  :: Double -> Double -> IO Double
+casadi_max__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_max__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_max__1" c_casadi_max__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_max__1
+  :: SX -> SX -> IO SX
+casadi_max__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_max__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_max__2" c_casadi_max__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_max__2
+  :: DM -> DM -> IO DM
+casadi_max__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_max__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_max__3" c_casadi_max__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_max__3
+  :: IM -> IM -> IO IM
+casadi_max__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_max__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_max__4" c_casadi_max__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_max__4
+  :: MX -> MX -> IO MX
+casadi_max__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_max__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_min__0" c_casadi_min__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_min__0
+  :: Double -> Double -> IO Double
+casadi_min__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_min__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_min__1" c_casadi_min__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_min__1
+  :: SX -> SX -> IO SX
+casadi_min__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_min__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_min__2" c_casadi_min__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_min__2
+  :: DM -> DM -> IO DM
+casadi_min__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_min__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_min__3" c_casadi_min__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_min__3
+  :: IM -> IM -> IO IM
+casadi_min__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_min__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_min__4" c_casadi_min__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_min__4
+  :: MX -> MX -> IO MX
+casadi_min__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_min__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_minus__0" c_casadi_minus__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_minus__0
+  :: Double -> Double -> IO Double
+casadi_minus__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_minus__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_minus__1" c_casadi_minus__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_minus__1
+  :: SX -> SX -> IO SX
+casadi_minus__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_minus__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_minus__2" c_casadi_minus__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_minus__2
+  :: DM -> DM -> IO DM
+casadi_minus__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_minus__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_minus__3" c_casadi_minus__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_minus__3
+  :: IM -> IM -> IO IM
+casadi_minus__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_minus__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_minus__4" c_casadi_minus__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_minus__4
+  :: MX -> MX -> IO MX
+casadi_minus__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_minus__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mldivide__0" c_casadi_mldivide__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_mldivide__0
+  :: SX -> SX -> IO SX
+casadi_mldivide__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mldivide__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mldivide__1" c_casadi_mldivide__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_mldivide__1
+  :: DM -> DM -> IO DM
+casadi_mldivide__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mldivide__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mldivide__2" c_casadi_mldivide__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_mldivide__2
+  :: IM -> IM -> IO IM
+casadi_mldivide__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mldivide__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mldivide__3" c_casadi_mldivide__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_mldivide__3
+  :: MX -> MX -> IO MX
+casadi_mldivide__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mldivide__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mod__0" c_casadi_mod__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_mod__0
+  :: Double -> Double -> IO Double
+casadi_mod__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mod__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mod__1" c_casadi_mod__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_mod__1
+  :: SX -> SX -> IO SX
+casadi_mod__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mod__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mod__2" c_casadi_mod__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_mod__2
+  :: DM -> DM -> IO DM
+casadi_mod__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mod__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mod__3" c_casadi_mod__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_mod__3
+  :: IM -> IM -> IO IM
+casadi_mod__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mod__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mod__4" c_casadi_mod__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_mod__4
+  :: MX -> MX -> IO MX
+casadi_mod__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mod__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mpower__0" c_casadi_mpower__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_mpower__0
+  :: SX -> SX -> IO SX
+casadi_mpower__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mpower__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mpower__1" c_casadi_mpower__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_mpower__1
+  :: DM -> DM -> IO DM
+casadi_mpower__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mpower__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mpower__2" c_casadi_mpower__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_mpower__2
+  :: IM -> IM -> IO IM
+casadi_mpower__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mpower__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mpower__3" c_casadi_mpower__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_mpower__3
+  :: MX -> MX -> IO MX
+casadi_mpower__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mpower__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mrdivide__0" c_casadi_mrdivide__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_mrdivide__0
+  :: SX -> SX -> IO SX
+casadi_mrdivide__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mrdivide__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mrdivide__1" c_casadi_mrdivide__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_mrdivide__1
+  :: DM -> DM -> IO DM
+casadi_mrdivide__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mrdivide__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mrdivide__2" c_casadi_mrdivide__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_mrdivide__2
+  :: IM -> IM -> IO IM
+casadi_mrdivide__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mrdivide__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mrdivide__3" c_casadi_mrdivide__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_mrdivide__3
+  :: MX -> MX -> IO MX
+casadi_mrdivide__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mrdivide__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__0" c_casadi_mtaylor__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr SX')
+
+casadi_mtaylor__0
+  :: SX -> SX -> SX -> Int -> Vector Int -> IO SX
+casadi_mtaylor__0 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__1" c_casadi_mtaylor__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_mtaylor__1
+  :: SX -> SX -> SX -> IO SX
+casadi_mtaylor__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__2" c_casadi_mtaylor__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_mtaylor__2
+  :: SX -> SX -> SX -> Int -> IO SX
+casadi_mtaylor__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__3" c_casadi_mtaylor__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr DM')
+
+casadi_mtaylor__3
+  :: DM -> DM -> DM -> Int -> Vector Int -> IO DM
+casadi_mtaylor__3 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__3 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__4" c_casadi_mtaylor__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_mtaylor__4
+  :: DM -> DM -> DM -> IO DM
+casadi_mtaylor__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__5" c_casadi_mtaylor__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_mtaylor__5
+  :: DM -> DM -> DM -> Int -> IO DM
+casadi_mtaylor__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__6" c_casadi_mtaylor__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr IM')
+
+casadi_mtaylor__6
+  :: IM -> IM -> IM -> Int -> Vector Int -> IO IM
+casadi_mtaylor__6 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__6 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__7" c_casadi_mtaylor__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_mtaylor__7
+  :: IM -> IM -> IM -> IO IM
+casadi_mtaylor__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtaylor__8" c_casadi_mtaylor__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_mtaylor__8
+  :: IM -> IM -> IM -> Int -> IO IM
+casadi_mtaylor__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtaylor__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__0" c_casadi_mtimes__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+
+casadi_mtimes__0
+  :: Vector SX -> IO SX
+casadi_mtimes__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__1" c_casadi_mtimes__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_mtimes__1
+  :: SX -> SX -> IO SX
+casadi_mtimes__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__2" c_casadi_mtimes__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> IO (Ptr DM')
+
+casadi_mtimes__2
+  :: Vector DM -> IO DM
+casadi_mtimes__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__3" c_casadi_mtimes__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_mtimes__3
+  :: DM -> DM -> IO DM
+casadi_mtimes__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__4" c_casadi_mtimes__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> IO (Ptr IM')
+
+casadi_mtimes__4
+  :: Vector IM -> IO IM
+casadi_mtimes__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__5" c_casadi_mtimes__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_mtimes__5
+  :: IM -> IM -> IO IM
+casadi_mtimes__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__6" c_casadi_mtimes__6
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi_mtimes__6
+  :: Vector MX -> IO MX
+casadi_mtimes__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__7" c_casadi_mtimes__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_mtimes__7
+  :: MX -> MX -> IO MX
+casadi_mtimes__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__8" c_casadi_mtimes__8
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+
+casadi_mtimes__8
+  :: Vector Sparsity -> IO Sparsity
+casadi_mtimes__8 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__8 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_mtimes__9" c_casadi_mtimes__9
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_mtimes__9
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi_mtimes__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_mtimes__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_n_nodes__0" c_casadi_n_nodes__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi_n_nodes__0
+  :: SX -> IO Int
+casadi_n_nodes__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_n_nodes__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_n_nodes__1" c_casadi_n_nodes__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi_n_nodes__1
+  :: DM -> IO Int
+casadi_n_nodes__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_n_nodes__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_n_nodes__2" c_casadi_n_nodes__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi_n_nodes__2
+  :: IM -> IO Int
+casadi_n_nodes__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_n_nodes__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_n_nodes__3" c_casadi_n_nodes__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi_n_nodes__3
+  :: MX -> IO Int
+casadi_n_nodes__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_n_nodes__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ne__0" c_casadi_ne__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_ne__0
+  :: Double -> Double -> IO Double
+casadi_ne__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ne__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ne__1" c_casadi_ne__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_ne__1
+  :: SX -> SX -> IO SX
+casadi_ne__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ne__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ne__2" c_casadi_ne__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_ne__2
+  :: DM -> DM -> IO DM
+casadi_ne__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ne__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ne__3" c_casadi_ne__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_ne__3
+  :: IM -> IM -> IO IM
+casadi_ne__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ne__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ne__4" c_casadi_ne__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_ne__4
+  :: MX -> MX -> IO MX
+casadi_ne__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ne__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nl_var__0" c_casadi_nl_var__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr (StdVec CInt))
+
+casadi_nl_var__0
+  :: SX -> SX -> IO (Vector Bool)
+casadi_nl_var__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nl_var__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nl_var__1" c_casadi_nl_var__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr (StdVec CInt))
+
+casadi_nl_var__1
+  :: DM -> DM -> IO (Vector Bool)
+casadi_nl_var__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nl_var__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nl_var__2" c_casadi_nl_var__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr (StdVec CInt))
+
+casadi_nl_var__2
+  :: IM -> IM -> IO (Vector Bool)
+casadi_nl_var__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nl_var__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nl_var__3" c_casadi_nl_var__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr (StdVec CInt))
+
+casadi_nl_var__3
+  :: MX -> MX -> IO (Vector Bool)
+casadi_nl_var__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nl_var__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_0_mul__0" c_casadi_norm_0_mul__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
+
+casadi_norm_0_mul__0
+  :: SX -> SX -> IO Int
+casadi_norm_0_mul__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_0_mul__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_0_mul__1" c_casadi_norm_0_mul__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO CInt
+
+casadi_norm_0_mul__1
+  :: DM -> DM -> IO Int
+casadi_norm_0_mul__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_0_mul__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_0_mul__2" c_casadi_norm_0_mul__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO CInt
+
+casadi_norm_0_mul__2
+  :: IM -> IM -> IO Int
+casadi_norm_0_mul__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_0_mul__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_0_mul__3" c_casadi_norm_0_mul__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
+
+casadi_norm_0_mul__3
+  :: MX -> MX -> IO Int
+casadi_norm_0_mul__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_0_mul__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_0_mul__4" c_casadi_norm_0_mul__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
+
+casadi_norm_0_mul__4
+  :: Sparsity -> Sparsity -> IO Int
+casadi_norm_0_mul__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_0_mul__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_1__0" c_casadi_norm_1__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_norm_1__0
+  :: SX -> IO SX
+casadi_norm_1__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_1__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_1__1" c_casadi_norm_1__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_norm_1__1
+  :: DM -> IO DM
+casadi_norm_1__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_1__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_1__2" c_casadi_norm_1__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_norm_1__2
+  :: IM -> IO IM
+casadi_norm_1__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_1__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_1__3" c_casadi_norm_1__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_norm_1__3
+  :: MX -> IO MX
+casadi_norm_1__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_1__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_2__0" c_casadi_norm_2__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_norm_2__0
+  :: SX -> IO SX
+casadi_norm_2__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_2__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_2__1" c_casadi_norm_2__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_norm_2__1
+  :: DM -> IO DM
+casadi_norm_2__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_2__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_2__2" c_casadi_norm_2__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_norm_2__2
+  :: IM -> IO IM
+casadi_norm_2__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_2__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_2__3" c_casadi_norm_2__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_norm_2__3
+  :: MX -> IO MX
+casadi_norm_2__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_2__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_F__0" c_casadi_norm_F__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_norm_F__0
+  :: SX -> IO SX
+casadi_norm_F__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_F__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_F__1" c_casadi_norm_F__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_norm_F__1
+  :: DM -> IO DM
+casadi_norm_F__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_F__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_F__2" c_casadi_norm_F__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_norm_F__2
+  :: IM -> IO IM
+casadi_norm_F__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_F__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_F__3" c_casadi_norm_F__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_norm_F__3
+  :: MX -> IO MX
+casadi_norm_F__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_F__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_inf__0" c_casadi_norm_inf__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_norm_inf__0
+  :: SX -> IO SX
+casadi_norm_inf__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_inf__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_inf__1" c_casadi_norm_inf__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_norm_inf__1
+  :: DM -> IO DM
+casadi_norm_inf__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_inf__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_inf__2" c_casadi_norm_inf__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_norm_inf__2
+  :: IM -> IO IM
+casadi_norm_inf__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_inf__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_inf__3" c_casadi_norm_inf__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_norm_inf__3
+  :: MX -> IO MX
+casadi_norm_inf__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_inf__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_inf_mul__0" c_casadi_norm_inf_mul__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_norm_inf_mul__0
+  :: SX -> SX -> IO SX
+casadi_norm_inf_mul__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_inf_mul__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_inf_mul__1" c_casadi_norm_inf_mul__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_norm_inf_mul__1
+  :: DM -> DM -> IO DM
+casadi_norm_inf_mul__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_inf_mul__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_norm_inf_mul__2" c_casadi_norm_inf_mul__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_norm_inf_mul__2
+  :: IM -> IM -> IO IM
+casadi_norm_inf_mul__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_norm_inf_mul__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_not__0" c_casadi_not__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_not__0
+  :: Double -> IO Double
+casadi_not__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_not__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_not__1" c_casadi_not__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_not__1
+  :: SX -> IO SX
+casadi_not__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_not__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_not__2" c_casadi_not__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_not__2
+  :: DM -> IO DM
+casadi_not__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_not__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_not__3" c_casadi_not__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_not__3
+  :: IM -> IO IM
+casadi_not__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_not__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_not__4" c_casadi_not__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_not__4
+  :: MX -> IO MX
+casadi_not__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_not__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nullspace__0" c_casadi_nullspace__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_nullspace__0
+  :: SX -> IO SX
+casadi_nullspace__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nullspace__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nullspace__1" c_casadi_nullspace__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_nullspace__1
+  :: DM -> IO DM
+casadi_nullspace__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nullspace__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nullspace__2" c_casadi_nullspace__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_nullspace__2
+  :: IM -> IO IM
+casadi_nullspace__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nullspace__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_nullspace__3" c_casadi_nullspace__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_nullspace__3
+  :: MX -> IO MX
+casadi_nullspace__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_nullspace__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__0" c_casadi_offset__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec CInt))
+
+casadi_offset__0
+  :: Vector SX -> IO (Vector Int)
+casadi_offset__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__1" c_casadi_offset__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi_offset__1
+  :: Vector SX -> Bool -> IO (Vector Int)
+casadi_offset__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__2" c_casadi_offset__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> IO (Ptr (StdVec CInt))
+
+casadi_offset__2
+  :: Vector DM -> IO (Vector Int)
+casadi_offset__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__3" c_casadi_offset__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi_offset__3
+  :: Vector DM -> Bool -> IO (Vector Int)
+casadi_offset__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__4" c_casadi_offset__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> IO (Ptr (StdVec CInt))
+
+casadi_offset__4
+  :: Vector IM -> IO (Vector Int)
+casadi_offset__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__5" c_casadi_offset__5
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi_offset__5
+  :: Vector IM -> Bool -> IO (Vector Int)
+casadi_offset__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__6" c_casadi_offset__6
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec CInt))
+
+casadi_offset__6
+  :: Vector MX -> IO (Vector Int)
+casadi_offset__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__7" c_casadi_offset__7
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi_offset__7
+  :: Vector MX -> Bool -> IO (Vector Int)
+casadi_offset__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__8" c_casadi_offset__8
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec CInt))
+
+casadi_offset__8
+  :: Vector Sparsity -> IO (Vector Int)
+casadi_offset__8 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__8 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_offset__9" c_casadi_offset__9
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> CInt -> IO (Ptr (StdVec CInt))
+
+casadi_offset__9
+  :: Vector Sparsity -> Bool -> IO (Vector Int)
+casadi_offset__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_offset__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_or__0" c_casadi_or__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_or__0
+  :: Double -> Double -> IO Double
+casadi_or__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_or__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_or__1" c_casadi_or__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_or__1
+  :: SX -> SX -> IO SX
+casadi_or__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_or__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_or__2" c_casadi_or__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_or__2
+  :: DM -> DM -> IO DM
+casadi_or__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_or__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_or__3" c_casadi_or__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_or__3
+  :: IM -> IM -> IO IM
+casadi_or__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_or__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_or__4" c_casadi_or__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_or__4
+  :: MX -> MX -> IO MX
+casadi_or__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_or__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__0" c_casadi_pinv__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr StdString -> IO (Ptr SX')
+
+casadi_pinv__0
+  :: SX -> String -> IO SX
+casadi_pinv__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__1" c_casadi_pinv__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SX')
+
+casadi_pinv__1
+  :: SX -> String -> M.Map String GenericType -> IO SX
+casadi_pinv__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__2" c_casadi_pinv__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_pinv__2
+  :: SX -> IO SX
+casadi_pinv__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__3" c_casadi_pinv__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr StdString -> IO (Ptr DM')
+
+casadi_pinv__3
+  :: DM -> String -> IO DM
+casadi_pinv__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__4" c_casadi_pinv__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DM')
+
+casadi_pinv__4
+  :: DM -> String -> M.Map String GenericType -> IO DM
+casadi_pinv__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__5" c_casadi_pinv__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_pinv__5
+  :: DM -> IO DM
+casadi_pinv__5 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__5 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__6" c_casadi_pinv__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr StdString -> IO (Ptr IM')
+
+casadi_pinv__6
+  :: IM -> String -> IO IM
+casadi_pinv__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__7" c_casadi_pinv__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr IM')
+
+casadi_pinv__7
+  :: IM -> String -> M.Map String GenericType -> IO IM
+casadi_pinv__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__8" c_casadi_pinv__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_pinv__8
+  :: IM -> IO IM
+casadi_pinv__8 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__8 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__9" c_casadi_pinv__9
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+
+casadi_pinv__9
+  :: MX -> String -> IO MX
+casadi_pinv__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__10" c_casadi_pinv__10
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX')
+
+casadi_pinv__10
+  :: MX -> String -> M.Map String GenericType -> IO MX
+casadi_pinv__10 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__10 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pinv__11" c_casadi_pinv__11
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_pinv__11
+  :: MX -> IO MX
+casadi_pinv__11 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pinv__11 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_plus__0" c_casadi_plus__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_plus__0
+  :: Double -> Double -> IO Double
+casadi_plus__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_plus__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_plus__1" c_casadi_plus__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_plus__1
+  :: SX -> SX -> IO SX
+casadi_plus__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_plus__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_plus__2" c_casadi_plus__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_plus__2
+  :: DM -> DM -> IO DM
+casadi_plus__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_plus__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_plus__3" c_casadi_plus__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_plus__3
+  :: IM -> IM -> IO IM
+casadi_plus__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_plus__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_plus__4" c_casadi_plus__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_plus__4
+  :: MX -> MX -> IO MX
+casadi_plus__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_plus__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_poly_coeff__0" c_casadi_poly_coeff__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_poly_coeff__0
+  :: SX -> SX -> IO SX
+casadi_poly_coeff__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_poly_coeff__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_poly_coeff__1" c_casadi_poly_coeff__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_poly_coeff__1
+  :: DM -> DM -> IO DM
+casadi_poly_coeff__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_poly_coeff__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_poly_coeff__2" c_casadi_poly_coeff__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_poly_coeff__2
+  :: IM -> IM -> IO IM
+casadi_poly_coeff__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_poly_coeff__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_poly_roots__0" c_casadi_poly_roots__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_poly_roots__0
+  :: SX -> IO SX
+casadi_poly_roots__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_poly_roots__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_poly_roots__1" c_casadi_poly_roots__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_poly_roots__1
+  :: DM -> IO DM
+casadi_poly_roots__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_poly_roots__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_poly_roots__2" c_casadi_poly_roots__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_poly_roots__2
+  :: IM -> IO IM
+casadi_poly_roots__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_poly_roots__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_polyval__0" c_casadi_polyval__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_polyval__0
+  :: SX -> SX -> IO SX
+casadi_polyval__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_polyval__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_polyval__1" c_casadi_polyval__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_polyval__1
+  :: DM -> DM -> IO DM
+casadi_polyval__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_polyval__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_polyval__2" c_casadi_polyval__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_polyval__2
+  :: IM -> IM -> IO IM
+casadi_polyval__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_polyval__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_polyval__3" c_casadi_polyval__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_polyval__3
+  :: MX -> MX -> IO MX
+casadi_polyval__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_polyval__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_power__0" c_casadi_power__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_power__0
+  :: Double -> Double -> IO Double
+casadi_power__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_power__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_power__1" c_casadi_power__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_power__1
+  :: SX -> SX -> IO SX
+casadi_power__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_power__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_power__2" c_casadi_power__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_power__2
+  :: DM -> DM -> IO DM
+casadi_power__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_power__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_power__3" c_casadi_power__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_power__3
+  :: IM -> IM -> IO IM
+casadi_power__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_power__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_power__4" c_casadi_power__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_power__4
+  :: MX -> MX -> IO MX
+casadi_power__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_power__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_print_operator__0" c_casadi_print_operator__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
+
+casadi_print_operator__0
+  :: SX -> Vector String -> IO String
+casadi_print_operator__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_print_operator__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_print_operator__1" c_casadi_print_operator__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
+
+casadi_print_operator__1
+  :: DM -> Vector String -> IO String
+casadi_print_operator__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_print_operator__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_print_operator__2" c_casadi_print_operator__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
+
+casadi_print_operator__2
+  :: IM -> Vector String -> IO String
+casadi_print_operator__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_print_operator__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_print_operator__3" c_casadi_print_operator__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
+
+casadi_print_operator__3
+  :: MX -> Vector String -> IO String
+casadi_print_operator__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_print_operator__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__0" c_casadi_project__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi_project__0
+  :: SX -> Sparsity -> IO SX
+casadi_project__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__1" c_casadi_project__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> CInt -> IO (Ptr SX')
+
+casadi_project__1
+  :: SX -> Sparsity -> Bool -> IO SX
+casadi_project__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__2" c_casadi_project__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi_project__2
+  :: DM -> Sparsity -> IO DM
+casadi_project__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__3" c_casadi_project__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr Sparsity' -> CInt -> IO (Ptr DM')
+
+casadi_project__3
+  :: DM -> Sparsity -> Bool -> IO DM
+casadi_project__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__4" c_casadi_project__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi_project__4
+  :: IM -> Sparsity -> IO IM
+casadi_project__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__5" c_casadi_project__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr Sparsity' -> CInt -> IO (Ptr IM')
+
+casadi_project__5
+  :: IM -> Sparsity -> Bool -> IO IM
+casadi_project__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__6" c_casadi_project__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi_project__6
+  :: MX -> Sparsity -> IO MX
+casadi_project__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_project__7" c_casadi_project__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX')
+
+casadi_project__7
+  :: MX -> Sparsity -> Bool -> IO MX
+casadi_project__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_project__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pw_const__0" c_casadi_pw_const__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_pw_const__0
+  :: SX -> SX -> SX -> IO SX
+casadi_pw_const__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pw_const__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pw_const__1" c_casadi_pw_const__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_pw_const__1
+  :: DM -> DM -> DM -> IO DM
+casadi_pw_const__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pw_const__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pw_const__2" c_casadi_pw_const__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_pw_const__2
+  :: IM -> IM -> IM -> IO IM
+casadi_pw_const__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pw_const__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pw_lin__0" c_casadi_pw_lin__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_pw_lin__0
+  :: SX -> SX -> SX -> IO SX
+casadi_pw_lin__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pw_lin__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pw_lin__1" c_casadi_pw_lin__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_pw_lin__1
+  :: DM -> DM -> DM -> IO DM
+casadi_pw_lin__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pw_lin__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_pw_lin__2" c_casadi_pw_lin__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_pw_lin__2
+  :: IM -> IM -> IM -> IO IM
+casadi_pw_lin__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_pw_lin__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_qr__0" c_casadi_qr__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
+
+casadi_qr__0
+  :: SX -> SX -> SX -> IO ()
+casadi_qr__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_qr__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_qr__1" c_casadi_qr__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO ()
+
+casadi_qr__1
+  :: DM -> DM -> DM -> IO ()
+casadi_qr__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_qr__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_qr__2" c_casadi_qr__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO ()
+
+casadi_qr__2
+  :: IM -> IM -> IM -> IO ()
+casadi_qr__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_qr__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_ramp__0" c_casadi_ramp__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_ramp__0
+  :: SX -> IO SX
+casadi_ramp__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ramp__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ramp__1" c_casadi_ramp__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_ramp__1
+  :: DM -> IO DM
+casadi_ramp__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ramp__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_ramp__2" c_casadi_ramp__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_ramp__2
+  :: IM -> IO IM
+casadi_ramp__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_ramp__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rank1__0" c_casadi_rank1__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_rank1__0
+  :: SX -> SX -> SX -> SX -> IO SX
+casadi_rank1__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rank1__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rank1__1" c_casadi_rank1__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_rank1__1
+  :: DM -> DM -> DM -> DM -> IO DM
+casadi_rank1__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rank1__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rank1__2" c_casadi_rank1__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_rank1__2
+  :: IM -> IM -> IM -> IM -> IO IM
+casadi_rank1__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rank1__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rank1__3" c_casadi_rank1__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_rank1__3
+  :: MX -> MX -> MX -> MX -> IO MX
+casadi_rank1__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rank1__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rdivide__0" c_casadi_rdivide__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_rdivide__0
+  :: Double -> Double -> IO Double
+casadi_rdivide__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rdivide__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rdivide__1" c_casadi_rdivide__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_rdivide__1
+  :: SX -> SX -> IO SX
+casadi_rdivide__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rdivide__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rdivide__2" c_casadi_rdivide__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_rdivide__2
+  :: DM -> DM -> IO DM
+casadi_rdivide__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rdivide__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rdivide__3" c_casadi_rdivide__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_rdivide__3
+  :: IM -> IM -> IO IM
+casadi_rdivide__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rdivide__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rdivide__4" c_casadi_rdivide__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_rdivide__4
+  :: MX -> MX -> IO MX
+casadi_rdivide__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rdivide__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rectangle__0" c_casadi_rectangle__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_rectangle__0
+  :: SX -> IO SX
+casadi_rectangle__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rectangle__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rectangle__1" c_casadi_rectangle__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_rectangle__1
+  :: DM -> IO DM
+casadi_rectangle__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rectangle__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_rectangle__2" c_casadi_rectangle__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_rectangle__2
+  :: IM -> IO IM
+casadi_rectangle__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_rectangle__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__0" c_casadi_repmat__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi_repmat__0
+  :: SX -> (Int, Int) -> IO SX
+casadi_repmat__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__1" c_casadi_repmat__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_repmat__1
+  :: SX -> Int -> IO SX
+casadi_repmat__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__2" c_casadi_repmat__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi_repmat__2
+  :: SX -> Int -> Int -> IO SX
+casadi_repmat__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__3" c_casadi_repmat__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi_repmat__3
+  :: DM -> (Int, Int) -> IO DM
+casadi_repmat__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__4" c_casadi_repmat__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_repmat__4
+  :: DM -> Int -> IO DM
+casadi_repmat__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__5" c_casadi_repmat__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi_repmat__5
+  :: DM -> Int -> Int -> IO DM
+casadi_repmat__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__6" c_casadi_repmat__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi_repmat__6
+  :: IM -> (Int, Int) -> IO IM
+casadi_repmat__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__7" c_casadi_repmat__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_repmat__7
+  :: IM -> Int -> IO IM
+casadi_repmat__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__8" c_casadi_repmat__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi_repmat__8
+  :: IM -> Int -> Int -> IO IM
+casadi_repmat__8 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__8 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__9" c_casadi_repmat__9
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
+
+casadi_repmat__9
+  :: MX -> (Int, Int) -> IO MX
+casadi_repmat__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__10" c_casadi_repmat__10
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_repmat__10
+  :: MX -> Int -> IO MX
+casadi_repmat__10 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__10 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__11" c_casadi_repmat__11
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
+
+casadi_repmat__11
+  :: MX -> Int -> Int -> IO MX
+casadi_repmat__11 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__11 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__12" c_casadi_repmat__12
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
+
+casadi_repmat__12
+  :: Sparsity -> (Int, Int) -> IO Sparsity
+casadi_repmat__12 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__12 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__13" c_casadi_repmat__13
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+
+casadi_repmat__13
+  :: Sparsity -> Int -> IO Sparsity
+casadi_repmat__13 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__13 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repmat__14" c_casadi_repmat__14
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi_repmat__14
+  :: Sparsity -> Int -> Int -> IO Sparsity
+casadi_repmat__14 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repmat__14 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__0" c_casadi_repsum__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_repsum__0
+  :: SX -> Int -> IO SX
+casadi_repsum__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__1" c_casadi_repsum__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi_repsum__1
+  :: SX -> Int -> Int -> IO SX
+casadi_repsum__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__2" c_casadi_repsum__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_repsum__2
+  :: DM -> Int -> IO DM
+casadi_repsum__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__3" c_casadi_repsum__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi_repsum__3
+  :: DM -> Int -> Int -> IO DM
+casadi_repsum__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__4" c_casadi_repsum__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_repsum__4
+  :: IM -> Int -> IO IM
+casadi_repsum__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__5" c_casadi_repsum__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi_repsum__5
+  :: IM -> Int -> Int -> IO IM
+casadi_repsum__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__6" c_casadi_repsum__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_repsum__6
+  :: MX -> Int -> IO MX
+casadi_repsum__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_repsum__7" c_casadi_repsum__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
+
+casadi_repsum__7
+  :: MX -> Int -> Int -> IO MX
+casadi_repsum__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_repsum__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__0" c_casadi_reshape__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
+
+casadi_reshape__0
+  :: SX -> Sparsity -> IO SX
+casadi_reshape__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__1" c_casadi_reshape__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX')
+
+casadi_reshape__1
+  :: SX -> (Int, Int) -> IO SX
+casadi_reshape__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__2" c_casadi_reshape__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+
+casadi_reshape__2
+  :: SX -> Int -> Int -> IO SX
+casadi_reshape__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__3" c_casadi_reshape__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr Sparsity' -> IO (Ptr DM')
+
+casadi_reshape__3
+  :: DM -> Sparsity -> IO DM
+casadi_reshape__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__4" c_casadi_reshape__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdPair CInt CInt) -> IO (Ptr DM')
+
+casadi_reshape__4
+  :: DM -> (Int, Int) -> IO DM
+casadi_reshape__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__5" c_casadi_reshape__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> CInt -> IO (Ptr DM')
+
+casadi_reshape__5
+  :: DM -> Int -> Int -> IO DM
+casadi_reshape__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__6" c_casadi_reshape__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr Sparsity' -> IO (Ptr IM')
+
+casadi_reshape__6
+  :: IM -> Sparsity -> IO IM
+casadi_reshape__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__7" c_casadi_reshape__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdPair CInt CInt) -> IO (Ptr IM')
+
+casadi_reshape__7
+  :: IM -> (Int, Int) -> IO IM
+casadi_reshape__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__8" c_casadi_reshape__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> CInt -> IO (Ptr IM')
+
+casadi_reshape__8
+  :: IM -> Int -> Int -> IO IM
+casadi_reshape__8 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__8 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__9" c_casadi_reshape__9
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
+
+casadi_reshape__9
+  :: MX -> Sparsity -> IO MX
+casadi_reshape__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__10" c_casadi_reshape__10
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdPair CInt CInt) -> IO (Ptr MX')
+
+casadi_reshape__10
+  :: MX -> (Int, Int) -> IO MX
+casadi_reshape__10 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__10 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__11" c_casadi_reshape__11
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
+
+casadi_reshape__11
+  :: MX -> Int -> Int -> IO MX
+casadi_reshape__11 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__11 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__12" c_casadi_reshape__12
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_reshape__12
+  :: Sparsity -> Sparsity -> IO Sparsity
+casadi_reshape__12 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__12 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__13" c_casadi_reshape__13
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
+
+casadi_reshape__13
+  :: Sparsity -> (Int, Int) -> IO Sparsity
+casadi_reshape__13 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__13 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_reshape__14" c_casadi_reshape__14
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
+
+casadi_reshape__14
+  :: Sparsity -> Int -> Int -> IO Sparsity
+casadi_reshape__14 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_reshape__14 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_shared__0" c_casadi_shared__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
+
+casadi_shared__0
+  :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> IO ()
+casadi_shared__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__1" c_casadi_shared__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO ()
+
+casadi_shared__1
+  :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> String -> IO ()
+casadi_shared__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__2" c_casadi_shared__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO ()
+
+casadi_shared__2
+  :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> String -> String -> IO ()
+casadi_shared__2 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__2 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__3" c_casadi_shared__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> IO ()
+
+casadi_shared__3
+  :: Vector DM -> Vector DM -> Vector DM -> Vector DM -> IO ()
+casadi_shared__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__4" c_casadi_shared__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr StdString -> IO ()
+
+casadi_shared__4
+  :: Vector DM -> Vector DM -> Vector DM -> Vector DM -> String -> IO ()
+casadi_shared__4 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__4 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__5" c_casadi_shared__5
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr StdString -> Ptr StdString -> IO ()
+
+casadi_shared__5
+  :: Vector DM -> Vector DM -> Vector DM -> Vector DM -> String -> String -> IO ()
+casadi_shared__5 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__5 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__6" c_casadi_shared__6
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> IO ()
+
+casadi_shared__6
+  :: Vector IM -> Vector IM -> Vector IM -> Vector IM -> IO ()
+casadi_shared__6 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__6 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__7" c_casadi_shared__7
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr StdString -> IO ()
+
+casadi_shared__7
+  :: Vector IM -> Vector IM -> Vector IM -> Vector IM -> String -> IO ()
+casadi_shared__7 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__7 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__8" c_casadi_shared__8
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr StdString -> Ptr StdString -> IO ()
+
+casadi_shared__8
+  :: Vector IM -> Vector IM -> Vector IM -> Vector IM -> String -> String -> IO ()
+casadi_shared__8 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__8 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__9" c_casadi_shared__9
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
+
+casadi_shared__9
+  :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> IO ()
+casadi_shared__9 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__9 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__10" c_casadi_shared__10
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO ()
+
+casadi_shared__10
+  :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> String -> IO ()
+casadi_shared__10 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__10 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_shared__11" c_casadi_shared__11
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO ()
+
+casadi_shared__11
+  :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> String -> String -> IO ()
+casadi_shared__11 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_shared__11 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_sign__0" c_casadi_sign__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_sign__0
+  :: Double -> IO Double
+casadi_sign__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sign__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sign__1" c_casadi_sign__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sign__1
+  :: SX -> IO SX
+casadi_sign__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sign__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sign__2" c_casadi_sign__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sign__2
+  :: DM -> IO DM
+casadi_sign__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sign__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sign__3" c_casadi_sign__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sign__3
+  :: IM -> IO IM
+casadi_sign__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sign__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sign__4" c_casadi_sign__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_sign__4
+  :: MX -> IO MX
+casadi_sign__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sign__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_simplify__0" c_casadi_simplify__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_simplify__0
+  :: Double -> IO Double
+casadi_simplify__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_simplify__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_simplify__1" c_casadi_simplify__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_simplify__1
+  :: SX -> IO SX
+casadi_simplify__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_simplify__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_simplify__2" c_casadi_simplify__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_simplify__2
+  :: DM -> IO DM
+casadi_simplify__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_simplify__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_simplify__3" c_casadi_simplify__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_simplify__3
+  :: IM -> IO IM
+casadi_simplify__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_simplify__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_simplify__4" c_casadi_simplify__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_simplify__4
+  :: MX -> IO MX
+casadi_simplify__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_simplify__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sin__0" c_casadi_sin__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_sin__0
+  :: Double -> IO Double
+casadi_sin__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sin__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sin__1" c_casadi_sin__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sin__1
+  :: SX -> IO SX
+casadi_sin__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sin__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sin__2" c_casadi_sin__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sin__2
+  :: DM -> IO DM
+casadi_sin__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sin__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sin__3" c_casadi_sin__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sin__3
+  :: IM -> IO IM
+casadi_sin__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sin__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sin__4" c_casadi_sin__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_sin__4
+  :: MX -> IO MX
+casadi_sin__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sin__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sinh__0" c_casadi_sinh__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_sinh__0
+  :: Double -> IO Double
+casadi_sinh__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sinh__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sinh__1" c_casadi_sinh__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sinh__1
+  :: SX -> IO SX
+casadi_sinh__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sinh__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sinh__2" c_casadi_sinh__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sinh__2
+  :: DM -> IO DM
+casadi_sinh__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sinh__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sinh__3" c_casadi_sinh__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sinh__3
+  :: IM -> IO IM
+casadi_sinh__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sinh__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sinh__4" c_casadi_sinh__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_sinh__4
+  :: MX -> IO MX
+casadi_sinh__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sinh__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_skew__0" c_casadi_skew__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_skew__0
+  :: SX -> IO SX
+casadi_skew__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_skew__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_skew__1" c_casadi_skew__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_skew__1
+  :: DM -> IO DM
+casadi_skew__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_skew__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_skew__2" c_casadi_skew__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_skew__2
+  :: IM -> IO IM
+casadi_skew__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_skew__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_skew__3" c_casadi_skew__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_skew__3
+  :: MX -> IO MX
+casadi_skew__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_skew__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__0" c_casadi_solve__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr StdString -> IO (Ptr SX')
+
+casadi_solve__0
+  :: SX -> SX -> String -> IO SX
+casadi_solve__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__1" c_casadi_solve__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SX')
+
+casadi_solve__1
+  :: SX -> SX -> String -> M.Map String GenericType -> IO SX
+casadi_solve__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__2" c_casadi_solve__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_solve__2
+  :: SX -> SX -> IO SX
+casadi_solve__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__3" c_casadi_solve__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr StdString -> IO (Ptr DM')
+
+casadi_solve__3
+  :: DM -> DM -> String -> IO DM
+casadi_solve__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__4" c_casadi_solve__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DM')
+
+casadi_solve__4
+  :: DM -> DM -> String -> M.Map String GenericType -> IO DM
+casadi_solve__4 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__4 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__5" c_casadi_solve__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_solve__5
+  :: DM -> DM -> IO DM
+casadi_solve__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__6" c_casadi_solve__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr StdString -> IO (Ptr IM')
+
+casadi_solve__6
+  :: IM -> IM -> String -> IO IM
+casadi_solve__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__7" c_casadi_solve__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr IM')
+
+casadi_solve__7
+  :: IM -> IM -> String -> M.Map String GenericType -> IO IM
+casadi_solve__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__8" c_casadi_solve__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_solve__8
+  :: IM -> IM -> IO IM
+casadi_solve__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__9" c_casadi_solve__9
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+
+casadi_solve__9
+  :: MX -> MX -> String -> IO MX
+casadi_solve__9 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__9 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__10" c_casadi_solve__10
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX')
+
+casadi_solve__10
+  :: MX -> MX -> String -> M.Map String GenericType -> IO MX
+casadi_solve__10 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__10 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_solve__11" c_casadi_solve__11
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_solve__11
+  :: MX -> MX -> IO MX
+casadi_solve__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_solve__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sparsify__0" c_casadi_sparsify__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sparsify__0
+  :: SX -> IO SX
+casadi_sparsify__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sparsify__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sparsify__1" c_casadi_sparsify__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO (Ptr SX')
+
+casadi_sparsify__1
+  :: SX -> Double -> IO SX
+casadi_sparsify__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sparsify__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sparsify__2" c_casadi_sparsify__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sparsify__2
+  :: DM -> IO DM
+casadi_sparsify__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sparsify__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sparsify__3" c_casadi_sparsify__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CDouble -> IO (Ptr DM')
+
+casadi_sparsify__3
+  :: DM -> Double -> IO DM
+casadi_sparsify__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sparsify__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sparsify__4" c_casadi_sparsify__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sparsify__4
+  :: IM -> IO IM
+casadi_sparsify__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sparsify__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sparsify__5" c_casadi_sparsify__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CDouble -> IO (Ptr IM')
+
+casadi_sparsify__5
+  :: IM -> Double -> IO IM
+casadi_sparsify__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sparsify__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sprank__0" c_casadi_sprank__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+
+casadi_sprank__0
+  :: SX -> IO Int
+casadi_sprank__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sprank__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sprank__1" c_casadi_sprank__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO CInt
+
+casadi_sprank__1
+  :: DM -> IO Int
+casadi_sprank__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sprank__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sprank__2" c_casadi_sprank__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+casadi_sprank__2
+  :: IM -> IO Int
+casadi_sprank__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sprank__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sprank__3" c_casadi_sprank__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
+
+casadi_sprank__3
+  :: MX -> IO Int
+casadi_sprank__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sprank__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sprank__4" c_casadi_sprank__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+
+casadi_sprank__4
+  :: Sparsity -> IO Int
+casadi_sprank__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sprank__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sqrt__0" c_casadi_sqrt__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_sqrt__0
+  :: Double -> IO Double
+casadi_sqrt__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sqrt__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sqrt__1" c_casadi_sqrt__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sqrt__1
+  :: SX -> IO SX
+casadi_sqrt__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sqrt__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sqrt__2" c_casadi_sqrt__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sqrt__2
+  :: DM -> IO DM
+casadi_sqrt__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sqrt__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sqrt__3" c_casadi_sqrt__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sqrt__3
+  :: IM -> IO IM
+casadi_sqrt__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sqrt__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sqrt__4" c_casadi_sqrt__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_sqrt__4
+  :: MX -> IO MX
+casadi_sqrt__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sqrt__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__0" c_casadi_substitute__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_substitute__0
+  :: Vector SX -> Vector SX -> Vector SX -> IO (Vector SX)
+casadi_substitute__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__1" c_casadi_substitute__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_substitute__1
+  :: SX -> SX -> SX -> IO SX
+casadi_substitute__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__2" c_casadi_substitute__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_substitute__2
+  :: Vector DM -> Vector DM -> Vector DM -> IO (Vector DM)
+casadi_substitute__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__3" c_casadi_substitute__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_substitute__3
+  :: DM -> DM -> DM -> IO DM
+casadi_substitute__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__4" c_casadi_substitute__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_substitute__4
+  :: Vector IM -> Vector IM -> Vector IM -> IO (Vector IM)
+casadi_substitute__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__5" c_casadi_substitute__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_substitute__5
+  :: IM -> IM -> IM -> IO IM
+casadi_substitute__5 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__5 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__6" c_casadi_substitute__6
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_substitute__6
+  :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
+casadi_substitute__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute__7" c_casadi_substitute__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_substitute__7
+  :: MX -> MX -> MX -> IO MX
+casadi_substitute__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__0" c_casadi_substitute_inplace__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
+
+casadi_substitute_inplace__0
+  :: Vector SX -> Vector SX -> Vector SX -> IO ()
+casadi_substitute_inplace__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__1" c_casadi_substitute_inplace__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
+
+casadi_substitute_inplace__1
+  :: Vector SX -> Vector SX -> Vector SX -> Bool -> IO ()
+casadi_substitute_inplace__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__2" c_casadi_substitute_inplace__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> IO ()
+
+casadi_substitute_inplace__2
+  :: Vector DM -> Vector DM -> Vector DM -> IO ()
+casadi_substitute_inplace__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__3" c_casadi_substitute_inplace__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> Ptr (StdVec (Ptr DM')) -> CInt -> IO ()
+
+casadi_substitute_inplace__3
+  :: Vector DM -> Vector DM -> Vector DM -> Bool -> IO ()
+casadi_substitute_inplace__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__4" c_casadi_substitute_inplace__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> IO ()
+
+casadi_substitute_inplace__4
+  :: Vector IM -> Vector IM -> Vector IM -> IO ()
+casadi_substitute_inplace__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__5" c_casadi_substitute_inplace__5
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> Ptr (StdVec (Ptr IM')) -> CInt -> IO ()
+
+casadi_substitute_inplace__5
+  :: Vector IM -> Vector IM -> Vector IM -> Bool -> IO ()
+casadi_substitute_inplace__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__6" c_casadi_substitute_inplace__6
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
+
+casadi_substitute_inplace__6
+  :: Vector MX -> Vector MX -> Vector MX -> IO ()
+casadi_substitute_inplace__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_substitute_inplace__7" c_casadi_substitute_inplace__7
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO ()
+
+casadi_substitute_inplace__7
+  :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO ()
+casadi_substitute_inplace__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_substitute_inplace__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ()
+
+
+
+foreign import ccall unsafe "casadi_sum1__0" c_casadi_sum1__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sum1__0
+  :: SX -> IO SX
+casadi_sum1__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum1__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum1__1" c_casadi_sum1__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sum1__1
+  :: DM -> IO DM
+casadi_sum1__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum1__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum1__2" c_casadi_sum1__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sum1__2
+  :: IM -> IO IM
+casadi_sum1__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum1__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum1__3" c_casadi_sum1__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_sum1__3
+  :: MX -> IO MX
+casadi_sum1__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum1__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum2__0" c_casadi_sum2__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sum2__0
+  :: SX -> IO SX
+casadi_sum2__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum2__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum2__1" c_casadi_sum2__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sum2__1
+  :: DM -> IO DM
+casadi_sum2__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum2__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum2__2" c_casadi_sum2__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sum2__2
+  :: IM -> IO IM
+casadi_sum2__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum2__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum2__3" c_casadi_sum2__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_sum2__3
+  :: MX -> IO MX
+casadi_sum2__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum2__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum_square__0" c_casadi_sum_square__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_sum_square__0
+  :: SX -> IO SX
+casadi_sum_square__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum_square__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum_square__1" c_casadi_sum_square__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_sum_square__1
+  :: DM -> IO DM
+casadi_sum_square__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum_square__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum_square__2" c_casadi_sum_square__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_sum_square__2
+  :: IM -> IO IM
+casadi_sum_square__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum_square__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_sum_square__3" c_casadi_sum_square__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_sum_square__3
+  :: MX -> IO MX
+casadi_sum_square__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_sum_square__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_symvar__0" c_casadi_symvar__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_symvar__0
+  :: SX -> IO (Vector SX)
+casadi_symvar__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_symvar__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_symvar__1" c_casadi_symvar__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_symvar__1
+  :: DM -> IO (Vector DM)
+casadi_symvar__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_symvar__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_symvar__2" c_casadi_symvar__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_symvar__2
+  :: IM -> IO (Vector IM)
+casadi_symvar__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_symvar__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_symvar__3" c_casadi_symvar__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_symvar__3
+  :: MX -> IO (Vector MX)
+casadi_symvar__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_symvar__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tan__0" c_casadi_tan__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_tan__0
+  :: Double -> IO Double
+casadi_tan__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tan__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tan__1" c_casadi_tan__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_tan__1
+  :: SX -> IO SX
+casadi_tan__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tan__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tan__2" c_casadi_tan__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_tan__2
+  :: DM -> IO DM
+casadi_tan__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tan__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tan__3" c_casadi_tan__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_tan__3
+  :: IM -> IO IM
+casadi_tan__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tan__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tan__4" c_casadi_tan__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_tan__4
+  :: MX -> IO MX
+casadi_tan__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tan__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tangent__0" c_casadi_tangent__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_tangent__0
+  :: SX -> SX -> IO SX
+casadi_tangent__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tangent__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tangent__1" c_casadi_tangent__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_tangent__1
+  :: DM -> DM -> IO DM
+casadi_tangent__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tangent__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tangent__2" c_casadi_tangent__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_tangent__2
+  :: IM -> IM -> IO IM
+casadi_tangent__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tangent__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tangent__3" c_casadi_tangent__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_tangent__3
+  :: MX -> MX -> IO MX
+casadi_tangent__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tangent__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tanh__0" c_casadi_tanh__0
+  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
+
+casadi_tanh__0
+  :: Double -> IO Double
+casadi_tanh__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tanh__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tanh__1" c_casadi_tanh__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_tanh__1
+  :: SX -> IO SX
+casadi_tanh__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tanh__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tanh__2" c_casadi_tanh__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_tanh__2
+  :: DM -> IO DM
+casadi_tanh__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tanh__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tanh__3" c_casadi_tanh__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_tanh__3
+  :: IM -> IO IM
+casadi_tanh__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tanh__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tanh__4" c_casadi_tanh__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_tanh__4
+  :: MX -> IO MX
+casadi_tanh__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tanh__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__0" c_casadi_taylor__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_taylor__0
+  :: SX -> SX -> IO SX
+casadi_taylor__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__1" c_casadi_taylor__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_taylor__1
+  :: SX -> SX -> SX -> IO SX
+casadi_taylor__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__2" c_casadi_taylor__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_taylor__2
+  :: SX -> SX -> SX -> Int -> IO SX
+casadi_taylor__2 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__2 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__3" c_casadi_taylor__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_taylor__3
+  :: DM -> DM -> IO DM
+casadi_taylor__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__4" c_casadi_taylor__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_taylor__4
+  :: DM -> DM -> DM -> IO DM
+casadi_taylor__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__5" c_casadi_taylor__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_taylor__5
+  :: DM -> DM -> DM -> Int -> IO DM
+casadi_taylor__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__6" c_casadi_taylor__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_taylor__6
+  :: IM -> IM -> IO IM
+casadi_taylor__6 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__6 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__7" c_casadi_taylor__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_taylor__7
+  :: IM -> IM -> IM -> IO IM
+casadi_taylor__7 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__7 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_taylor__8" c_casadi_taylor__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_taylor__8
+  :: IM -> IM -> IM -> Int -> IO IM
+casadi_taylor__8 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_taylor__8 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_times__0" c_casadi_times__0
+  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
+
+casadi_times__0
+  :: Double -> Double -> IO Double
+casadi_times__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_times__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_times__1" c_casadi_times__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_times__1
+  :: SX -> SX -> IO SX
+casadi_times__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_times__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_times__2" c_casadi_times__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_times__2
+  :: DM -> DM -> IO DM
+casadi_times__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_times__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_times__3" c_casadi_times__3
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_times__3
+  :: IM -> IM -> IO IM
+casadi_times__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_times__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_times__4" c_casadi_times__4
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_times__4
+  :: MX -> MX -> IO MX
+casadi_times__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_times__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_trace__0" c_casadi_trace__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_trace__0
+  :: SX -> IO SX
+casadi_trace__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_trace__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_trace__1" c_casadi_trace__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_trace__1
+  :: DM -> IO DM
+casadi_trace__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_trace__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_trace__2" c_casadi_trace__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_trace__2
+  :: IM -> IO IM
+casadi_trace__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_trace__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_trace__3" c_casadi_trace__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_trace__3
+  :: MX -> IO MX
+casadi_trace__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_trace__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_transpose__0" c_casadi_transpose__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_transpose__0
+  :: SX -> IO SX
+casadi_transpose__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_transpose__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_transpose__1" c_casadi_transpose__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_transpose__1
+  :: DM -> IO DM
+casadi_transpose__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_transpose__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_transpose__2" c_casadi_transpose__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_transpose__2
+  :: IM -> IO IM
+casadi_transpose__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_transpose__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_transpose__3" c_casadi_transpose__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_transpose__3
+  :: MX -> IO MX
+casadi_transpose__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_transpose__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_transpose__4" c_casadi_transpose__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_transpose__4
+  :: Sparsity -> IO Sparsity
+casadi_transpose__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_transpose__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triangle__0" c_casadi_triangle__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_triangle__0
+  :: SX -> IO SX
+casadi_triangle__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triangle__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triangle__1" c_casadi_triangle__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_triangle__1
+  :: DM -> IO DM
+casadi_triangle__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triangle__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triangle__2" c_casadi_triangle__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_triangle__2
+  :: IM -> IO IM
+casadi_triangle__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triangle__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__0" c_casadi_tril__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_tril__0
+  :: SX -> IO SX
+casadi_tril__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__1" c_casadi_tril__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_tril__1
+  :: SX -> Bool -> IO SX
+casadi_tril__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__2" c_casadi_tril__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_tril__2
+  :: DM -> IO DM
+casadi_tril__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__3" c_casadi_tril__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_tril__3
+  :: DM -> Bool -> IO DM
+casadi_tril__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__4" c_casadi_tril__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_tril__4
+  :: IM -> IO IM
+casadi_tril__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__5" c_casadi_tril__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_tril__5
+  :: IM -> Bool -> IO IM
+casadi_tril__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__6" c_casadi_tril__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_tril__6
+  :: MX -> IO MX
+casadi_tril__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__7" c_casadi_tril__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_tril__7
+  :: MX -> Bool -> IO MX
+casadi_tril__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__8" c_casadi_tril__8
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_tril__8
+  :: Sparsity -> IO Sparsity
+casadi_tril__8 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__8 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril__9" c_casadi_tril__9
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+
+casadi_tril__9
+  :: Sparsity -> Bool -> IO Sparsity
+casadi_tril__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril2symm__0" c_casadi_tril2symm__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_tril2symm__0
+  :: SX -> IO SX
+casadi_tril2symm__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril2symm__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril2symm__1" c_casadi_tril2symm__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_tril2symm__1
+  :: DM -> IO DM
+casadi_tril2symm__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril2symm__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril2symm__2" c_casadi_tril2symm__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_tril2symm__2
+  :: IM -> IO IM
+casadi_tril2symm__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril2symm__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_tril2symm__3" c_casadi_tril2symm__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_tril2symm__3
+  :: MX -> IO MX
+casadi_tril2symm__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_tril2symm__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__0" c_casadi_triu__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_triu__0
+  :: SX -> IO SX
+casadi_triu__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__1" c_casadi_triu__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX')
+
+casadi_triu__1
+  :: SX -> Bool -> IO SX
+casadi_triu__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__2" c_casadi_triu__2
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_triu__2
+  :: DM -> IO DM
+casadi_triu__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__3" c_casadi_triu__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr DM')
+
+casadi_triu__3
+  :: DM -> Bool -> IO DM
+casadi_triu__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__4" c_casadi_triu__4
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_triu__4
+  :: IM -> IO IM
+casadi_triu__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__5" c_casadi_triu__5
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr IM')
+
+casadi_triu__5
+  :: IM -> Bool -> IO IM
+casadi_triu__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__6" c_casadi_triu__6
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_triu__6
+  :: MX -> IO MX
+casadi_triu__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__7" c_casadi_triu__7
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX')
+
+casadi_triu__7
+  :: MX -> Bool -> IO MX
+casadi_triu__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__8" c_casadi_triu__8
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_triu__8
+  :: Sparsity -> IO Sparsity
+casadi_triu__8 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__8 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu__9" c_casadi_triu__9
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+
+casadi_triu__9
+  :: Sparsity -> Bool -> IO Sparsity
+casadi_triu__9 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu__9 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu2symm__0" c_casadi_triu2symm__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_triu2symm__0
+  :: SX -> IO SX
+casadi_triu2symm__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu2symm__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu2symm__1" c_casadi_triu2symm__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_triu2symm__1
+  :: DM -> IO DM
+casadi_triu2symm__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu2symm__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu2symm__2" c_casadi_triu2symm__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_triu2symm__2
+  :: IM -> IO IM
+casadi_triu2symm__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu2symm__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_triu2symm__3" c_casadi_triu2symm__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_triu2symm__3
+  :: MX -> IO MX
+casadi_triu2symm__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_triu2symm__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_unite__0" c_casadi_unite__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+
+casadi_unite__0
+  :: SX -> SX -> IO SX
+casadi_unite__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_unite__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_unite__1" c_casadi_unite__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr DM' -> IO (Ptr DM')
+
+casadi_unite__1
+  :: DM -> DM -> IO DM
+casadi_unite__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_unite__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_unite__2" c_casadi_unite__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr IM' -> IO (Ptr IM')
+
+casadi_unite__2
+  :: IM -> IM -> IO IM
+casadi_unite__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_unite__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_unite__3" c_casadi_unite__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+
+casadi_unite__3
+  :: MX -> MX -> IO MX
+casadi_unite__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_unite__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vec__0" c_casadi_vec__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+
+casadi_vec__0
+  :: SX -> IO SX
+casadi_vec__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vec__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vec__1" c_casadi_vec__1
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr DM')
+
+casadi_vec__1
+  :: DM -> IO DM
+casadi_vec__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vec__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vec__2" c_casadi_vec__2
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr IM')
+
+casadi_vec__2
+  :: IM -> IO IM
+casadi_vec__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vec__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vec__3" c_casadi_vec__3
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+
+casadi_vec__3
+  :: MX -> IO MX
+casadi_vec__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vec__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vec__4" c_casadi_vec__4
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+
+casadi_vec__4
+  :: Sparsity -> IO Sparsity
+casadi_vec__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vec__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_veccat__0" c_casadi_veccat__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+
+casadi_veccat__0
+  :: Vector SX -> IO SX
+casadi_veccat__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_veccat__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_veccat__1" c_casadi_veccat__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> IO (Ptr DM')
+
+casadi_veccat__1
+  :: Vector DM -> IO DM
+casadi_veccat__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_veccat__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_veccat__2" c_casadi_veccat__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> IO (Ptr IM')
+
+casadi_veccat__2
+  :: Vector IM -> IO IM
+casadi_veccat__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_veccat__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_veccat__3" c_casadi_veccat__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi_veccat__3
+  :: Vector MX -> IO MX
+casadi_veccat__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_veccat__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_veccat__4" c_casadi_veccat__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+
+casadi_veccat__4
+  :: Vector Sparsity -> IO Sparsity
+casadi_veccat__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_veccat__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertcat__0" c_casadi_vertcat__0
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+
+casadi_vertcat__0
+  :: Vector SX -> IO SX
+casadi_vertcat__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertcat__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertcat__1" c_casadi_vertcat__1
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DM')) -> IO (Ptr DM')
+
+casadi_vertcat__1
+  :: Vector DM -> IO DM
+casadi_vertcat__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertcat__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertcat__2" c_casadi_vertcat__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IM')) -> IO (Ptr IM')
+
+casadi_vertcat__2
+  :: Vector IM -> IO IM
+casadi_vertcat__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertcat__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertcat__3" c_casadi_vertcat__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+
+casadi_vertcat__3
+  :: Vector MX -> IO MX
+casadi_vertcat__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertcat__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertcat__4" c_casadi_vertcat__4
+  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+
+casadi_vertcat__4
+  :: Vector Sparsity -> IO Sparsity
+casadi_vertcat__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertcat__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__0" c_casadi_vertsplit__0
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_vertsplit__0
+  :: SX -> IO (Vector SX)
+casadi_vertsplit__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__1" c_casadi_vertsplit__1
+  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_vertsplit__1
+  :: SX -> Int -> IO (Vector SX)
+casadi_vertsplit__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__2" c_casadi_vertsplit__2
+  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
+
+casadi_vertsplit__2
+  :: SX -> Vector Int -> IO (Vector SX)
+casadi_vertsplit__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__3" c_casadi_vertsplit__3
+  :: Ptr (Ptr StdString) -> Ptr DM' -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_vertsplit__3
+  :: DM -> IO (Vector DM)
+casadi_vertsplit__3 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__3 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__4" c_casadi_vertsplit__4
+  :: Ptr (Ptr StdString) -> Ptr DM' -> CInt -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_vertsplit__4
+  :: DM -> Int -> IO (Vector DM)
+casadi_vertsplit__4 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__4 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__5" c_casadi_vertsplit__5
+  :: Ptr (Ptr StdString) -> Ptr DM' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DM')))
+
+casadi_vertsplit__5
+  :: DM -> Vector Int -> IO (Vector DM)
+casadi_vertsplit__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__6" c_casadi_vertsplit__6
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_vertsplit__6
+  :: IM -> IO (Vector IM)
+casadi_vertsplit__6 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__6 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__7" c_casadi_vertsplit__7
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_vertsplit__7
+  :: IM -> Int -> IO (Vector IM)
+casadi_vertsplit__7 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__7 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__8" c_casadi_vertsplit__8
+  :: Ptr (Ptr StdString) -> Ptr IM' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IM')))
+
+casadi_vertsplit__8
+  :: IM -> Vector Int -> IO (Vector IM)
+casadi_vertsplit__8 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__8 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__9" c_casadi_vertsplit__9
+  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_vertsplit__9
+  :: MX -> IO (Vector MX)
+casadi_vertsplit__9 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__9 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__10" c_casadi_vertsplit__10
+  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_vertsplit__10
+  :: MX -> Int -> IO (Vector MX)
+casadi_vertsplit__10 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__10 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__11" c_casadi_vertsplit__11
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+
+casadi_vertsplit__11
+  :: MX -> Vector Int -> IO (Vector MX)
+casadi_vertsplit__11 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__11 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__12" c_casadi_vertsplit__12
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_vertsplit__12
+  :: Sparsity -> IO (Vector Sparsity)
+casadi_vertsplit__12 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__12 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__13" c_casadi_vertsplit__13
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_vertsplit__13
+  :: Sparsity -> Int -> IO (Vector Sparsity)
+casadi_vertsplit__13 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__13 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "casadi_vertsplit__14" c_casadi_vertsplit__14
+  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+
+casadi_vertsplit__14
+  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
+casadi_vertsplit__14 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_casadi_vertsplit__14 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "collocationInterpolators" c_collocationInterpolators
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> Ptr (Ptr (StdVec (Ptr (StdVec CDouble)))) -> Ptr (Ptr (StdVec CDouble)) -> IO ()
+
+collocationInterpolators
+  :: Vector Double -> IO (Vector (Vector Double), Vector Double)
+collocationInterpolators x0 = do
+  x0' <- marshal x0
+  o1' <- new nullPtr
+  o2' <- new nullPtr
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_collocationInterpolators errStrPtrP x0' o1' o2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  o1'' <- peek o1'
+  free o1'
+  o1''' <- if o1'' == nullPtr then error "swig output o1' was not set in collocationInterpolators/c_collocationInterpolators" else wrapReturn o1''
+  o2'' <- peek o2'
+  free o2'
+  o2''' <- if o2'' == nullPtr then error "swig output o2' was not set in collocationInterpolators/c_collocationInterpolators" else wrapReturn o2''
+
+  return (o1''', o2''')
+
+
+
+foreign import ccall unsafe "collocation_points__0" c_collocation_points__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec CDouble))
+
+collocation_points__0
+  :: Int -> IO (Vector Double)
+collocation_points__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_collocation_points__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "collocation_points__1" c_collocation_points__1
+  :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO (Ptr (StdVec CDouble))
+
+collocation_points__1
+  :: Int -> String -> IO (Vector Double)
+collocation_points__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_collocation_points__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "complement" c_complement
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
+
+complement
+  :: Vector Int -> Int -> IO (Vector Int)
+complement x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_complement errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "doc_integrator" c_doc_integrator
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
+doc_integrator
+  :: String -> IO String
+doc_integrator x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_doc_integrator errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "doc_linsol" c_doc_linsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
+doc_linsol
+  :: String -> IO String
+doc_linsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_doc_linsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "doc_nlpsol" c_doc_nlpsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
+doc_nlpsol
+  :: String -> IO String
+doc_nlpsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_doc_nlpsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "doc_qpsol" c_doc_qpsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
+doc_qpsol
+  :: String -> IO String
+doc_qpsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_doc_qpsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "doc_rootfinder" c_doc_rootfinder
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+
+doc_rootfinder
+  :: String -> IO String
+doc_rootfinder x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_doc_rootfinder errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "external__0" c_external__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Compiler' -> IO (Ptr Function')
+
+external__0
+  :: String -> Compiler -> IO Function
+external__0 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_external__0 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "external__1" c_external__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Compiler' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+external__1
+  :: String -> Compiler -> M.Map String GenericType -> IO Function
+external__1 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_external__1 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "external__2" c_external__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
+
+external__2
+  :: String -> String -> IO Function
+external__2 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_external__2 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "external__3" c_external__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+external__3
+  :: String -> String -> M.Map String GenericType -> IO Function
+external__3 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_external__3 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "external__4" c_external__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr Function')
+
+external__4
+  :: String -> IO Function
+external__4 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_external__4 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "external__5" c_external__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+external__5
+  :: String -> M.Map String GenericType -> IO Function
+external__5 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_external__5 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "has_integrator" c_has_integrator
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
+
+has_integrator
+  :: String -> IO Bool
+has_integrator x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_has_integrator errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "has_linsol" c_has_linsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
+
+has_linsol
+  :: String -> IO Bool
+has_linsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_has_linsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "has_nlpsol" c_has_nlpsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
+
+has_nlpsol
+  :: String -> IO Bool
+has_nlpsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_has_nlpsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "has_qpsol" c_has_qpsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
+
+has_qpsol
+  :: String -> IO Bool
+has_qpsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_has_qpsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "has_rootfinder" c_has_rootfinder
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt
+
+has_rootfinder
+  :: String -> IO Bool
+has_rootfinder x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_has_rootfinder errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "hash_combine" c_hash_combine
+  :: Ptr (Ptr StdString) -> CSize -> Ptr (StdVec CInt) -> IO ()
+
+hash_combine
+  :: CSize -> Vector Int -> IO ()
+hash_combine x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_hash_combine errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ()
+
+
+
+foreign import ccall unsafe "hash_sparsity" c_hash_sparsity
+  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CSize
+
+hash_sparsity
+  :: Int -> Int -> Vector Int -> Vector Int -> IO CSize
+hash_sparsity x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_hash_sparsity errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__0" c_integrator__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdPair (Ptr Function') (Ptr Function')) -> IO (Ptr Function')
+
+integrator__0
+  :: String -> String -> (Function, Function) -> IO Function
+integrator__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__1" c_integrator__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdPair (Ptr Function') (Ptr Function')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+integrator__1
+  :: String -> String -> (Function, Function) -> M.Map String GenericType -> IO Function
+integrator__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__2" c_integrator__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr Function')
+
+integrator__2
+  :: String -> String -> Function -> IO Function
+integrator__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__3" c_integrator__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+integrator__3
+  :: String -> String -> Function -> M.Map String GenericType -> IO Function
+integrator__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__4" c_integrator__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr Function')
+
+integrator__4
+  :: String -> String -> M.Map String MX -> IO Function
+integrator__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__5" c_integrator__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+integrator__5
+  :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO Function
+integrator__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__6" c_integrator__6
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr Function')
+
+integrator__6
+  :: String -> String -> M.Map String SX -> IO Function
+integrator__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator__7" c_integrator__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+integrator__7
+  :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO Function
+integrator__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator_in__0" c_integrator_in__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+integrator_in__0
+  :: Int -> IO String
+integrator_in__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator_in__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator_in__1" c_integrator_in__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+integrator_in__1
+  :: IO (Vector String)
+integrator_in__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator_in__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator_n_in" c_integrator_n_in
+  :: Ptr (Ptr StdString) -> IO CInt
+
+integrator_n_in
+  :: IO Int
+integrator_n_in  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator_n_in errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator_n_out" c_integrator_n_out
+  :: Ptr (Ptr StdString) -> IO CInt
+
+integrator_n_out
+  :: IO Int
+integrator_n_out  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator_n_out errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator_out__0" c_integrator_out__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+integrator_out__0
+  :: Int -> IO String
+integrator_out__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator_out__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "integrator_out__1" c_integrator_out__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+integrator_out__1
+  :: IO (Vector String)
+integrator_out__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_integrator_out__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "is_slice__0" c_is_slice__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO CInt
+
+is_slice__0
+  :: IM -> IO Bool
+is_slice__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_is_slice__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "is_slice__1" c_is_slice__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO CInt
+
+is_slice__1
+  :: IM -> Bool -> IO Bool
+is_slice__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_is_slice__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "is_slice__2" c_is_slice__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
+
+is_slice__2
+  :: Vector Int -> IO Bool
+is_slice__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_is_slice__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "is_slice__3" c_is_slice__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO CInt
+
+is_slice__3
+  :: Vector Int -> Bool -> IO Bool
+is_slice__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_is_slice__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "is_slice2" c_is_slice2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
+
+is_slice2
+  :: Vector Int -> IO Bool
+is_slice2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_is_slice2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "jit__0" c_jit__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> Ptr StdString -> IO (Ptr Function')
+
+jit__0
+  :: String -> Int -> Int -> String -> IO Function
+jit__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_jit__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "jit__1" c_jit__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+jit__1
+  :: String -> Int -> Int -> String -> M.Map String GenericType -> IO Function
+jit__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_jit__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol__0" c_linsol__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr Function')
+
+linsol__0
+  :: String -> String -> Sparsity -> Int -> IO Function
+linsol__0 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol__0 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol__1" c_linsol__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+linsol__1
+  :: String -> String -> Sparsity -> Int -> M.Map String GenericType -> IO Function
+linsol__1 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol__1 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol_in__0" c_linsol_in__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+linsol_in__0
+  :: Int -> IO String
+linsol_in__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol_in__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol_in__1" c_linsol_in__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+linsol_in__1
+  :: IO (Vector String)
+linsol_in__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol_in__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol_n_in" c_linsol_n_in
+  :: Ptr (Ptr StdString) -> IO CInt
+
+linsol_n_in
+  :: IO Int
+linsol_n_in  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol_n_in errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol_n_out" c_linsol_n_out
+  :: Ptr (Ptr StdString) -> IO CInt
+
+linsol_n_out
+  :: IO Int
+linsol_n_out  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol_n_out errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol_out__0" c_linsol_out__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+linsol_out__0
+  :: Int -> IO String
+linsol_out__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol_out__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "linsol_out__1" c_linsol_out__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+linsol_out__1
+  :: IO (Vector String)
+linsol_out__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_linsol_out__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "load_integrator" c_load_integrator
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
+load_integrator
+  :: String -> IO ()
+load_integrator x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_load_integrator errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+foreign import ccall unsafe "load_linsol" c_load_linsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
+load_linsol
+  :: String -> IO ()
+load_linsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_load_linsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+foreign import ccall unsafe "load_nlpsol" c_load_nlpsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
+load_nlpsol
+  :: String -> IO ()
+load_nlpsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_load_nlpsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+foreign import ccall unsafe "load_qpsol" c_load_qpsol
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
+load_qpsol
+  :: String -> IO ()
+load_qpsol x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_load_qpsol errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+foreign import ccall unsafe "load_rootfinder" c_load_rootfinder
+  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+
+load_rootfinder
+  :: String -> IO ()
+load_rootfinder x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_load_rootfinder errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ()
+
+
+
+foreign import ccall unsafe "lookupvector" c_lookupvector
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
+
+lookupvector
+  :: Vector Int -> Int -> IO (Vector Int)
+lookupvector x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_lookupvector errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__0" c_nlpsol__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Compiler' -> IO (Ptr Function')
+
+nlpsol__0
+  :: String -> String -> Compiler -> IO Function
+nlpsol__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__1" c_nlpsol__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Compiler' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+nlpsol__1
+  :: String -> String -> Compiler -> M.Map String GenericType -> IO Function
+nlpsol__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__2" c_nlpsol__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
+
+nlpsol__2
+  :: String -> String -> String -> IO Function
+nlpsol__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__3" c_nlpsol__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+nlpsol__3
+  :: String -> String -> String -> M.Map String GenericType -> IO Function
+nlpsol__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__4" c_nlpsol__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr Function')
+
+nlpsol__4
+  :: String -> String -> Function -> IO Function
+nlpsol__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__5" c_nlpsol__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+nlpsol__5
+  :: String -> String -> Function -> M.Map String GenericType -> IO Function
+nlpsol__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__6" c_nlpsol__6
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr Function')
+
+nlpsol__6
+  :: String -> String -> M.Map String MX -> IO Function
+nlpsol__6 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__6 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__7" c_nlpsol__7
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+nlpsol__7
+  :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO Function
+nlpsol__7 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__7 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__8" c_nlpsol__8
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr Function')
+
+nlpsol__8
+  :: String -> String -> M.Map String SX -> IO Function
+nlpsol__8 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__8 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol__9" c_nlpsol__9
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+nlpsol__9
+  :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO Function
+nlpsol__9 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol__9 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_default_in__0" c_nlpsol_default_in__0
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec CDouble))
+
+nlpsol_default_in__0
+  :: IO (Vector Double)
+nlpsol_default_in__0  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_default_in__0 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_default_in__1" c_nlpsol_default_in__1
+  :: Ptr (Ptr StdString) -> CInt -> IO CDouble
+
+nlpsol_default_in__1
+  :: Int -> IO Double
+nlpsol_default_in__1 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_default_in__1 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_in__0" c_nlpsol_in__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+nlpsol_in__0
+  :: Int -> IO String
+nlpsol_in__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_in__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_in__1" c_nlpsol_in__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+nlpsol_in__1
+  :: IO (Vector String)
+nlpsol_in__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_in__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_n_in" c_nlpsol_n_in
+  :: Ptr (Ptr StdString) -> IO CInt
+
+nlpsol_n_in
+  :: IO Int
+nlpsol_n_in  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_n_in errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_n_out" c_nlpsol_n_out
+  :: Ptr (Ptr StdString) -> IO CInt
+
+nlpsol_n_out
+  :: IO Int
+nlpsol_n_out  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_n_out errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_out__0" c_nlpsol_out__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+nlpsol_out__0
+  :: Int -> IO String
+nlpsol_out__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_out__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "nlpsol_out__1" c_nlpsol_out__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+nlpsol_out__1
+  :: IO (Vector String)
+nlpsol_out__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_nlpsol_out__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol__0" c_qpsol__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr Function')
+
+qpsol__0
+  :: String -> String -> M.Map String MX -> IO Function
+qpsol__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol__1" c_qpsol__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+qpsol__1
+  :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO Function
+qpsol__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol__2" c_qpsol__2
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr Function')
+
+qpsol__2
+  :: String -> String -> M.Map String SX -> IO Function
+qpsol__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol__3" c_qpsol__3
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+qpsol__3
+  :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO Function
+qpsol__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol__4" c_qpsol__4
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr Function')
+
+qpsol__4
+  :: String -> String -> M.Map String Sparsity -> IO Function
+qpsol__4 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol__4 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol__5" c_qpsol__5
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+qpsol__5
+  :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO Function
+qpsol__5 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol__5 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol_in__0" c_qpsol_in__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+qpsol_in__0
+  :: Int -> IO String
+qpsol_in__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol_in__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol_in__1" c_qpsol_in__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+qpsol_in__1
+  :: IO (Vector String)
+qpsol_in__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol_in__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol_n_in" c_qpsol_n_in
+  :: Ptr (Ptr StdString) -> IO CInt
+
+qpsol_n_in
+  :: IO Int
+qpsol_n_in  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol_n_in errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol_n_out" c_qpsol_n_out
+  :: Ptr (Ptr StdString) -> IO CInt
+
+qpsol_n_out
+  :: IO Int
+qpsol_n_out  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol_n_out errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol_out__0" c_qpsol_out__0
+  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString)
+
+qpsol_out__0
+  :: Int -> IO String
+qpsol_out__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol_out__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "qpsol_out__1" c_qpsol_out__1
+  :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString)))
+
+qpsol_out__1
+  :: IO (Vector String)
+qpsol_out__1  = do
+
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_qpsol_out__1 errStrPtrP 
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+
+
+  return ret
+
+
+
+foreign import ccall unsafe "rootfinder__0" c_rootfinder__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr Function')
+
+rootfinder__0
+  :: String -> String -> Function -> IO Function
+rootfinder__0 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_rootfinder__0 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "rootfinder__1" c_rootfinder__1
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+rootfinder__1
+  :: String -> String -> Function -> M.Map String GenericType -> IO Function
+rootfinder__1 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_rootfinder__1 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIRK__0" c_simpleIRK__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+simpleIRK__0
+  :: Function -> IO Function
+simpleIRK__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIRK__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIRK__1" c_simpleIRK__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+simpleIRK__1
+  :: Function -> Int -> IO Function
+simpleIRK__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIRK__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIRK__2" c_simpleIRK__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
+
+simpleIRK__2
+  :: Function -> Int -> Int -> IO Function
+simpleIRK__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIRK__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIRK__3" c_simpleIRK__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> IO (Ptr Function')
+
+simpleIRK__3
+  :: Function -> Int -> Int -> String -> IO Function
+simpleIRK__3 x0 x1 x2 x3 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIRK__3 errStrPtrP x0' x1' x2' x3'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIRK__4" c_simpleIRK__4
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
+
+simpleIRK__4
+  :: Function -> Int -> Int -> String -> String -> IO Function
+simpleIRK__4 x0 x1 x2 x3 x4 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIRK__4 errStrPtrP x0' x1' x2' x3' x4'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIRK__5" c_simpleIRK__5
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+simpleIRK__5
+  :: Function -> Int -> Int -> String -> String -> M.Map String GenericType -> IO Function
+simpleIRK__5 x0 x1 x2 x3 x4 x5 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+  x3' <- marshal x3
+  x4' <- marshal x4
+  x5' <- marshal x5
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIRK__5 errStrPtrP x0' x1' x2' x3' x4' x5'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+  marshalFree x3 x3'
+  marshalFree x4 x4'
+  marshalFree x5 x5'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIntegrator__0" c_simpleIntegrator__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+simpleIntegrator__0
+  :: Function -> IO Function
+simpleIntegrator__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIntegrator__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIntegrator__1" c_simpleIntegrator__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+
+simpleIntegrator__1
+  :: Function -> String -> IO Function
+simpleIntegrator__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIntegrator__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleIntegrator__2" c_simpleIntegrator__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function')
+
+simpleIntegrator__2
+  :: Function -> String -> M.Map String GenericType -> IO Function
+simpleIntegrator__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleIntegrator__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleRK__0" c_simpleRK__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+
+simpleRK__0
+  :: Function -> IO Function
+simpleRK__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleRK__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleRK__1" c_simpleRK__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
+
+simpleRK__1
+  :: Function -> Int -> IO Function
+simpleRK__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleRK__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "simpleRK__2" c_simpleRK__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
+
+simpleRK__2
+  :: Function -> Int -> Int -> IO Function
+simpleRK__2 x0 x1 x2 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+  x2' <- marshal x2
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_simpleRK__2 errStrPtrP x0' x1' x2'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+  marshalFree x2 x2'
+
+  return ret
+
+
+
+foreign import ccall unsafe "to_slice__0" c_to_slice__0
+  :: Ptr (Ptr StdString) -> Ptr IM' -> IO (Ptr Slice')
+
+to_slice__0
+  :: IM -> IO Slice
+to_slice__0 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_to_slice__0 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "to_slice__1" c_to_slice__1
+  :: Ptr (Ptr StdString) -> Ptr IM' -> CInt -> IO (Ptr Slice')
+
+to_slice__1
+  :: IM -> Bool -> IO Slice
+to_slice__1 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_to_slice__1 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "to_slice__2" c_to_slice__2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr Slice')
+
+to_slice__2
+  :: Vector Int -> IO Slice
+to_slice__2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_to_slice__2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
+
+
+foreign import ccall unsafe "to_slice__3" c_to_slice__3
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Slice')
+
+to_slice__3
+  :: Vector Int -> Bool -> IO Slice
+to_slice__3 x0 x1 = do
+  x0' <- marshal x0
+  x1' <- marshal x1
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_to_slice__3 errStrPtrP x0' x1'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+  marshalFree x1 x1'
+
+  return ret
+
+
+
+foreign import ccall unsafe "to_slice2" c_to_slice2
+  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr (StdPair (Ptr Slice') (Ptr Slice')))
+
+to_slice2
+  :: Vector Int -> IO (Slice, Slice)
+to_slice2 x0 = do
+  x0' <- marshal x0
+
+  errStrPtrP <- new nullPtr
+  ret0 <- c_to_slice2 errStrPtrP x0'
+  errStrPtr <- peek errStrPtrP
+  free errStrPtrP
+
+  ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException)
+
+  marshalFree x0 x0'
+
+  return ret
+
 
 
diff --git a/casadi-bindings-core.cabal b/casadi-bindings-core.cabal
--- a/casadi-bindings-core.cabal
+++ b/casadi-bindings-core.cabal
@@ -1,9 +1,9 @@
 name:                casadi-bindings-core
-version:             2.4.1.0
+version:             3.0.0.0
 license:             LGPL-3
 license-file:        LICENSE
 category:            Numerical, Math
-copyright:           (c) 2013-2015 Greg Horn
+copyright:           (c) 2013-2016 Greg Horn
 author:              Greg Horn
 maintainer:          gregmainland@gmail.com
 build-type:          Simple
@@ -11,13 +11,12 @@
 synopsis:            autogenerated low level bindings to casadi
 description:         see <http://hackage.haskell.org/package/casadi-bindings http://hackage.haskell.org/package/casadi-bindings> for all instructions
 extra-source-files:  cbits/marshal.hpp
-extra-tmp-files:     Casadi/Callback_stub.h
 
 library
   build-depends:       base >=4.6 && <5,
                        vector >=0.10,
                        containers >= 0.5,
-                       casadi-bindings-internal == 0.1.3.1
+                       casadi-bindings-internal == 0.1.4.0
 
   default-language:    Haskell2010
 
@@ -39,61 +38,26 @@
                     Casadi.Core.Tools
                     Casadi.Core.CustomWrappers
                     Casadi.Core.Classes.Callback
-                    Casadi.Core.Classes.Callback2
                     Casadi.Core.Classes.CasadiMeta
-                    Casadi.Core.Classes.CasadiOptions
-                    Casadi.Core.Classes.CleSolver
                     Casadi.Core.Classes.CodeGenerator
                     Casadi.Core.Classes.Compiler
-                    Casadi.Core.Classes.ControlSimulator
-                    Casadi.Core.Classes.CustomEvaluate
-                    Casadi.Core.Classes.CustomFunction
-                    Casadi.Core.Classes.DMatrix
+                    Casadi.Core.Classes.DM
                     Casadi.Core.Classes.DaeBuilder
-                    Casadi.Core.Classes.DerivativeGenerator
-                    Casadi.Core.Classes.DerivativeGenerator2
-                    Casadi.Core.Classes.DleSolver
-                    Casadi.Core.Classes.DpleSolver
-                    Casadi.Core.Classes.ExternalFunction
                     Casadi.Core.Classes.Function
-                    Casadi.Core.Classes.Functor
                     Casadi.Core.Classes.GenericExpressionCommon
                     Casadi.Core.Classes.GenericMatrixCommon
                     Casadi.Core.Classes.GenericType
-                    Casadi.Core.Classes.HomotopyNlpSolver
-                    Casadi.Core.Classes.IMatrix
-                    Casadi.Core.Classes.ImplicitFunction
-                    Casadi.Core.Classes.Integrator
-                    Casadi.Core.Classes.IterationCallback
-                    Casadi.Core.Classes.KernelSum2D
-                    Casadi.Core.Classes.LinearSolver
-                    Casadi.Core.Classes.LpSolver
-                    Casadi.Core.Classes.LrDleSolver
-                    Casadi.Core.Classes.LrDpleSolver
+                    Casadi.Core.Classes.GlobalOptions
+                    Casadi.Core.Classes.IM
+                    Casadi.Core.Classes.Library
                     Casadi.Core.Classes.MX
-                    Casadi.Core.Classes.MXFunction
-                    Casadi.Core.Classes.Map
-                    Casadi.Core.Classes.MapAccum
                     Casadi.Core.Classes.MatrixCommon
                     Casadi.Core.Classes.NlpBuilder
-                    Casadi.Core.Classes.NlpSolver
-                    Casadi.Core.Classes.Nullspace
-                    Casadi.Core.Classes.OptionsFunctionality
-                    Casadi.Core.Classes.QcqpSolver
-                    Casadi.Core.Classes.QpSolver
                     Casadi.Core.Classes.SX
-                    Casadi.Core.Classes.SXElement
-                    Casadi.Core.Classes.SXFunction
-                    Casadi.Core.Classes.SdpSolver
-                    Casadi.Core.Classes.SdqpSolver
+                    Casadi.Core.Classes.SXElem
                     Casadi.Core.Classes.SharedObject
-                    Casadi.Core.Classes.Simulator
                     Casadi.Core.Classes.Slice
-                    Casadi.Core.Classes.SocpSolver
                     Casadi.Core.Classes.Sparsity
                     Casadi.Core.Classes.SparsityInterfaceCommon
-                    Casadi.Core.Classes.StabilizedQpSolver
-                    Casadi.Core.Classes.Switch
                     Casadi.Core.Classes.Variable
                     Casadi.Core.Classes.XmlFile
-                    Casadi.Core.Classes.IOInterfaceFunction
diff --git a/cbits/autogen/casadi_wrap_classes.cpp b/cbits/autogen/casadi_wrap_classes.cpp
--- a/cbits/autogen/casadi_wrap_classes.cpp
+++ b/cbits/autogen/casadi_wrap_classes.cpp
@@ -16,46224 +16,42686 @@
 // class: "casadi::Callback"
 // cppName: "casadi::Callback"
 // cWrapperName: "casadi__Callback__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, casadi::IterationCallback* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Callback")
-// cWrapperRetType: "casadi::Callback*"
-// proto: "casadi::Callback*\n    casadi__Callback__CONSTRUCTOR__0(std::string ** err_msg, casadi::IterationCallback* x0)"
-// call: "casadi::Callback(x0_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IterationCallback"))]
-extern "C"
-casadi::Callback*
-    casadi__Callback__CONSTRUCTOR__0(std::string ** err_msg, casadi::IterationCallback* x0);
-casadi::Callback*
-    casadi__Callback__CONSTRUCTOR__0(std::string ** err_msg, casadi::IterationCallback* x0){
-    try {
-        casadi::IterationCallback& x0_ = Marshaling<casadi::IterationCallback&,casadi::IterationCallback*>::marshal(x0);
-
-        return new casadi::Callback(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Callback"
-// cppName: "casadi::Callback"
-// cWrapperName: "casadi__Callback__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Callback")
-// cWrapperRetType: "casadi::Callback*"
-// proto: "casadi::Callback*\n    casadi__Callback__CONSTRUCTOR__1(std::string ** err_msg)"
-// call: "casadi::Callback()"
-// params: []
-extern "C"
-casadi::Callback*
-    casadi__Callback__CONSTRUCTOR__1(std::string ** err_msg);
-casadi::Callback*
-    casadi__Callback__CONSTRUCTOR__1(std::string ** err_msg){
-    try {
-
-        return new casadi::Callback();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Callback2")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Callback2")
-extern "C"
-void delete_casadi__Callback2(casadi::Callback2* obj);
-void delete_casadi__Callback2(casadi::Callback2* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2"
-// cWrapperName: "casadi__Callback2__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Callback2")
-// cWrapperRetType: "casadi::Callback2*"
-// proto: "casadi::Callback2*\n    casadi__Callback2__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::Callback2()"
-// params: []
-extern "C"
-casadi::Callback2*
-    casadi__Callback2__CONSTRUCTOR(std::string ** err_msg);
-casadi::Callback2*
-    casadi__Callback2__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::Callback2();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "create" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::create"
-// cWrapperName: "casadi__Callback2__create"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Callback2__create(std::string ** err_msg, casadi::Callback2* obj)"
-// call: "obj->create()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Callback2__create(std::string ** err_msg, casadi::Callback2* obj);
-casadi::Function*
-    casadi__Callback2__create(std::string ** err_msg, casadi::Callback2* obj){
-    try {
-
-        casadi::Function ret = obj->create();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputShape" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::inputShape"
-// cWrapperName: "casadi__Callback2__inputShape"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__Callback2__inputShape(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// call: "obj->inputShape(x0_)"
-// params: [CInt]
-extern "C"
-std::pair< int, int >*
-    casadi__Callback2__inputShape(std::string ** err_msg, casadi::Callback2* obj, int x0);
-std::pair< int, int >*
-    casadi__Callback2__inputShape(std::string ** err_msg, casadi::Callback2* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::pair< int, int > ret = obj->inputShape(x0_);
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputSparsity" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::inputSparsity"
-// cWrapperName: "casadi__Callback2__inputSparsity"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Callback2__inputSparsity(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// call: "obj->inputSparsity(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Callback2__inputSparsity(std::string ** err_msg, casadi::Callback2* obj, int x0);
-casadi::Sparsity*
-    casadi__Callback2__inputSparsity(std::string ** err_msg, casadi::Callback2* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->inputSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nIn" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::nIn"
-// cWrapperName: "casadi__Callback2__nIn"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Callback2__nIn(std::string ** err_msg, casadi::Callback2* obj)"
-// call: "obj->nIn()"
-// params: []
-extern "C"
-int
-    casadi__Callback2__nIn(std::string ** err_msg, casadi::Callback2* obj);
-int
-    casadi__Callback2__nIn(std::string ** err_msg, casadi::Callback2* obj){
-    try {
-
-        int ret = obj->nIn();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nOut" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::nOut"
-// cWrapperName: "casadi__Callback2__nOut"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Callback2__nOut(std::string ** err_msg, casadi::Callback2* obj)"
-// call: "obj->nOut()"
-// params: []
-extern "C"
-int
-    casadi__Callback2__nOut(std::string ** err_msg, casadi::Callback2* obj);
-int
-    casadi__Callback2__nOut(std::string ** err_msg, casadi::Callback2* obj){
-    try {
-
-        int ret = obj->nOut();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "name" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::name"
-// cWrapperName: "casadi__Callback2__name"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Callback2__name(std::string ** err_msg, casadi::Callback2* obj)"
-// call: "obj->name()"
-// params: []
-extern "C"
-std::string*
-    casadi__Callback2__name(std::string ** err_msg, casadi::Callback2* obj);
-std::string*
-    casadi__Callback2__name(std::string ** err_msg, casadi::Callback2* obj){
-    try {
-
-        std::string ret = obj->name();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::operator ()"
-// cWrapperName: "casadi__Callback2__operator_call"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj, std::vector< casadi::DMatrix* >* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
-// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
-// proto: "std::vector< casadi::DMatrix* >*\n    casadi__Callback2__operator_call(std::string ** err_msg, casadi::Callback2* obj, std::vector< casadi::DMatrix* >* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
-extern "C"
-std::vector< casadi::DMatrix* >*
-    casadi__Callback2__operator_call(std::string ** err_msg, casadi::Callback2* obj, std::vector< casadi::DMatrix* >* x0);
-std::vector< casadi::DMatrix* >*
-    casadi__Callback2__operator_call(std::string ** err_msg, casadi::Callback2* obj, std::vector< casadi::DMatrix* >* x0){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-
-        std::vector< casadi::DMatrix > ret = obj->operator ()(x0_);
-        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "options" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::options"
-// cWrapperName: "casadi__Callback2__options"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj)"
-// args: "()"
-// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))
-// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
-// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__Callback2__options(std::string ** err_msg, casadi::Callback2* obj)"
-// call: "obj->options()"
-// params: []
-extern "C"
-std::map< std::string, casadi::GenericType* >*
-    casadi__Callback2__options(std::string ** err_msg, casadi::Callback2* obj);
-std::map< std::string, casadi::GenericType* >*
-    casadi__Callback2__options(std::string ** err_msg, casadi::Callback2* obj){
-    try {
-
-        std::map< std::string, casadi::GenericType > ret = obj->options();
-        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputShape" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::outputShape"
-// cWrapperName: "casadi__Callback2__outputShape"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__Callback2__outputShape(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// call: "obj->outputShape(x0_)"
-// params: [CInt]
-extern "C"
-std::pair< int, int >*
-    casadi__Callback2__outputShape(std::string ** err_msg, casadi::Callback2* obj, int x0);
-std::pair< int, int >*
-    casadi__Callback2__outputShape(std::string ** err_msg, casadi::Callback2* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::pair< int, int > ret = obj->outputShape(x0_);
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputSparsity" ===============
-// class: "casadi::Callback2"
-// cppName: "casadi::Callback2::outputSparsity"
-// cWrapperName: "casadi__Callback2__outputSparsity"
-// protoArgs: "(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Callback2__outputSparsity(std::string ** err_msg, casadi::Callback2* obj, int x0)"
-// call: "obj->outputSparsity(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Callback2__outputSparsity(std::string ** err_msg, casadi::Callback2* obj, int x0);
-casadi::Sparsity*
-    casadi__Callback2__outputSparsity(std::string ** err_msg, casadi::Callback2* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->outputSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "CasadiMeta")===============
-// classType: UserType (Namespace ["casadi"]) (Name "CasadiMeta")
-extern "C"
-void delete_casadi__CasadiMeta(casadi::CasadiMeta* obj);
-void delete_casadi__CasadiMeta(casadi::CasadiMeta* obj){
-    delete obj;
-}
-
-// ================== Static method: "getBuildType" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getBuildType"
-// cWrapperName: "casadi__CasadiMeta__getBuildType"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getBuildType(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getBuildType()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getBuildType(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getBuildType(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getBuildType();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getCompiler" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getCompiler"
-// cWrapperName: "casadi__CasadiMeta__getCompiler"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getCompiler(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getCompiler()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getCompiler(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getCompiler(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getCompiler();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getCompilerFlags" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getCompilerFlags"
-// cWrapperName: "casadi__CasadiMeta__getCompilerFlags"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getCompilerFlags()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getCompilerFlags();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getCompilerId" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getCompilerId"
-// cWrapperName: "casadi__CasadiMeta__getCompilerId"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getCompilerId(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getCompilerId()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getCompilerId(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getCompilerId(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getCompilerId();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getFeatureList" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getFeatureList"
-// cWrapperName: "casadi__CasadiMeta__getFeatureList"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getFeatureList(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getFeatureList()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getFeatureList(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getFeatureList(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getFeatureList();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getGitDescribe" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getGitDescribe"
-// cWrapperName: "casadi__CasadiMeta__getGitDescribe"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getGitDescribe(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getGitDescribe()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getGitDescribe(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getGitDescribe(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getGitDescribe();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getGitRevision" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getGitRevision"
-// cWrapperName: "casadi__CasadiMeta__getGitRevision"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getGitRevision(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getGitRevision()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getGitRevision(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getGitRevision(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getGitRevision();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getInstallPrefix" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getInstallPrefix"
-// cWrapperName: "casadi__CasadiMeta__getInstallPrefix"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getInstallPrefix(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getInstallPrefix()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getInstallPrefix(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getInstallPrefix(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getInstallPrefix();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getModules" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getModules"
-// cWrapperName: "casadi__CasadiMeta__getModules"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getModules(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getModules()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getModules(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getModules(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getModules();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getPlugins" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getPlugins"
-// cWrapperName: "casadi__CasadiMeta__getPlugins"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getPlugins(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getPlugins()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getPlugins(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getPlugins(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getPlugins();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getVersion" ===============
-// class: "casadi::CasadiMeta"
-// cppName: "casadi::CasadiMeta::getVersion"
-// cWrapperName: "casadi__CasadiMeta__getVersion"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiMeta__getVersion(std::string ** err_msg)"
-// call: "casadi::CasadiMeta::getVersion()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiMeta__getVersion(std::string ** err_msg);
-std::string*
-    casadi__CasadiMeta__getVersion(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiMeta::getVersion();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "CasadiOptions")===============
-// classType: UserType (Namespace ["casadi"]) (Name "CasadiOptions")
-extern "C"
-void delete_casadi__CasadiOptions(casadi::CasadiOptions* obj);
-void delete_casadi__CasadiOptions(casadi::CasadiOptions* obj){
-    delete obj;
-}
-
-// ================== Static method: "getAllowedInternalAPI" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::getAllowedInternalAPI"
-// cWrapperName: "casadi__CasadiOptions__getAllowedInternalAPI"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__CasadiOptions__getAllowedInternalAPI(std::string ** err_msg)"
-// call: "casadi::CasadiOptions::getAllowedInternalAPI()"
-// params: []
-extern "C"
-int
-    casadi__CasadiOptions__getAllowedInternalAPI(std::string ** err_msg);
-int
-    casadi__CasadiOptions__getAllowedInternalAPI(std::string ** err_msg){
-    try {
-
-        bool ret = casadi::CasadiOptions::getAllowedInternalAPI();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getCasadiPath" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::getCasadiPath"
-// cWrapperName: "casadi__CasadiOptions__getCasadiPath"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CasadiOptions__getCasadiPath(std::string ** err_msg)"
-// call: "casadi::CasadiOptions::getCasadiPath()"
-// params: []
-extern "C"
-std::string*
-    casadi__CasadiOptions__getCasadiPath(std::string ** err_msg);
-std::string*
-    casadi__CasadiOptions__getCasadiPath(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::CasadiOptions::getCasadiPath();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getCatchErrorsSwig" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::getCatchErrorsSwig"
-// cWrapperName: "casadi__CasadiOptions__getCatchErrorsSwig"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__CasadiOptions__getCatchErrorsSwig(std::string ** err_msg)"
-// call: "casadi::CasadiOptions::getCatchErrorsSwig()"
-// params: []
-extern "C"
-int
-    casadi__CasadiOptions__getCatchErrorsSwig(std::string ** err_msg);
-int
-    casadi__CasadiOptions__getCatchErrorsSwig(std::string ** err_msg){
-    try {
-
-        bool ret = casadi::CasadiOptions::getCatchErrorsSwig();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getProfilingBinary" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::getProfilingBinary"
-// cWrapperName: "casadi__CasadiOptions__getProfilingBinary"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__CasadiOptions__getProfilingBinary(std::string ** err_msg)"
-// call: "casadi::CasadiOptions::getProfilingBinary()"
-// params: []
-extern "C"
-int
-    casadi__CasadiOptions__getProfilingBinary(std::string ** err_msg);
-int
-    casadi__CasadiOptions__getProfilingBinary(std::string ** err_msg){
-    try {
-
-        bool ret = casadi::CasadiOptions::getProfilingBinary();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getSimplificationOnTheFly" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::getSimplificationOnTheFly"
-// cWrapperName: "casadi__CasadiOptions__getSimplificationOnTheFly"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__CasadiOptions__getSimplificationOnTheFly(std::string ** err_msg)"
-// call: "casadi::CasadiOptions::getSimplificationOnTheFly()"
-// params: []
-extern "C"
-int
-    casadi__CasadiOptions__getSimplificationOnTheFly(std::string ** err_msg);
-int
-    casadi__CasadiOptions__getSimplificationOnTheFly(std::string ** err_msg){
-    try {
-
-        bool ret = casadi::CasadiOptions::getSimplificationOnTheFly();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "setAllowedInternalAPI" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::setAllowedInternalAPI"
-// cWrapperName: "casadi__CasadiOptions__setAllowedInternalAPI"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__setAllowedInternalAPI(std::string ** err_msg, int x0)"
-// call: "casadi::CasadiOptions::setAllowedInternalAPI(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__CasadiOptions__setAllowedInternalAPI(std::string ** err_msg, int x0);
-void
-    casadi__CasadiOptions__setAllowedInternalAPI(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::CasadiOptions::setAllowedInternalAPI(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setCasadiPath" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::setCasadiPath"
-// cWrapperName: "casadi__CasadiOptions__setCasadiPath"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__setCasadiPath(std::string ** err_msg, std::string* x0)"
-// call: "casadi::CasadiOptions::setCasadiPath(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__CasadiOptions__setCasadiPath(std::string ** err_msg, std::string* x0);
-void
-    casadi__CasadiOptions__setCasadiPath(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::CasadiOptions::setCasadiPath(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setCatchErrorsSwig" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::setCatchErrorsSwig"
-// cWrapperName: "casadi__CasadiOptions__setCatchErrorsSwig"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__setCatchErrorsSwig(std::string ** err_msg, int x0)"
-// call: "casadi::CasadiOptions::setCatchErrorsSwig(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__CasadiOptions__setCatchErrorsSwig(std::string ** err_msg, int x0);
-void
-    casadi__CasadiOptions__setCatchErrorsSwig(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::CasadiOptions::setCatchErrorsSwig(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setProfilingBinary" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::setProfilingBinary"
-// cWrapperName: "casadi__CasadiOptions__setProfilingBinary"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__setProfilingBinary(std::string ** err_msg, int x0)"
-// call: "casadi::CasadiOptions::setProfilingBinary(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__CasadiOptions__setProfilingBinary(std::string ** err_msg, int x0);
-void
-    casadi__CasadiOptions__setProfilingBinary(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::CasadiOptions::setProfilingBinary(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setPurgeSeeds" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::setPurgeSeeds"
-// cWrapperName: "casadi__CasadiOptions__setPurgeSeeds__0"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__CasadiOptions__setPurgeSeeds__0(std::string ** err_msg)"
-// call: "casadi::CasadiOptions::setPurgeSeeds()"
-// params: []
-extern "C"
-int
-    casadi__CasadiOptions__setPurgeSeeds__0(std::string ** err_msg);
-int
-    casadi__CasadiOptions__setPurgeSeeds__0(std::string ** err_msg){
-    try {
-
-        bool ret = casadi::CasadiOptions::setPurgeSeeds();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "setPurgeSeeds" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::setPurgeSeeds"
-// cWrapperName: "casadi__CasadiOptions__setPurgeSeeds__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__setPurgeSeeds__1(std::string ** err_msg, int x0)"
-// call: "casadi::CasadiOptions::setPurgeSeeds(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__CasadiOptions__setPurgeSeeds__1(std::string ** err_msg, int x0);
-void
-    casadi__CasadiOptions__setPurgeSeeds__1(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::CasadiOptions::setPurgeSeeds(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setSimplificationOnTheFly" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::setSimplificationOnTheFly"
-// cWrapperName: "casadi__CasadiOptions__setSimplificationOnTheFly"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0)"
-// call: "casadi::CasadiOptions::setSimplificationOnTheFly(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__CasadiOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0);
-void
-    casadi__CasadiOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::CasadiOptions::setSimplificationOnTheFly(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "startProfiling" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::startProfiling"
-// cWrapperName: "casadi__CasadiOptions__startProfiling"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__startProfiling(std::string ** err_msg, std::string* x0)"
-// call: "casadi::CasadiOptions::startProfiling(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__CasadiOptions__startProfiling(std::string ** err_msg, std::string* x0);
-void
-    casadi__CasadiOptions__startProfiling(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::CasadiOptions::startProfiling(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "stopProfiling" ===============
-// class: "casadi::CasadiOptions"
-// cppName: "casadi::CasadiOptions::stopProfiling"
-// cWrapperName: "casadi__CasadiOptions__stopProfiling"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CasadiOptions__stopProfiling(std::string ** err_msg)"
-// call: "casadi::CasadiOptions::stopProfiling()"
-// params: []
-extern "C"
-void
-    casadi__CasadiOptions__stopProfiling(std::string ** err_msg);
-void
-    casadi__CasadiOptions__stopProfiling(std::string ** err_msg){
-    try {
-
-        casadi::CasadiOptions::stopProfiling();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "CleSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "CleSolver")
-extern "C"
-void delete_casadi__CleSolver(casadi::CleSolver* obj);
-void delete_casadi__CleSolver(casadi::CleSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver"
-// cWrapperName: "casadi__CleSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CleSolver")
-// cWrapperRetType: "casadi::CleSolver*"
-// proto: "casadi::CleSolver*\n    casadi__CleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::CleSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::CleSolver*
-    casadi__CleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::CleSolver*
-    casadi__CleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::CleSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver"
-// cWrapperName: "casadi__CleSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CleSolver")
-// cWrapperRetType: "casadi::CleSolver*"
-// proto: "casadi::CleSolver*\n    casadi__CleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::CleSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::CleSolver*
-    casadi__CleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::CleSolver*
-    casadi__CleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::CleSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver"
-// cWrapperName: "casadi__CleSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "CleSolver")
-// cWrapperRetType: "casadi::CleSolver*"
-// proto: "casadi::CleSolver*\n    casadi__CleSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::CleSolver()"
-// params: []
-extern "C"
-casadi::CleSolver*
-    casadi__CleSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::CleSolver*
-    casadi__CleSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::CleSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clone" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver::clone"
-// cWrapperName: "casadi__CleSolver__clone"
-// protoArgs: "(std::string ** err_msg, casadi::CleSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "CleSolver")
-// cWrapperRetType: "casadi::CleSolver*"
-// proto: "casadi::CleSolver*\n    casadi__CleSolver__clone(std::string ** err_msg, casadi::CleSolver* obj)"
-// call: "obj->clone()"
-// params: []
-extern "C"
-casadi::CleSolver*
-    casadi__CleSolver__clone(std::string ** err_msg, casadi::CleSolver* obj);
-casadi::CleSolver*
-    casadi__CleSolver__clone(std::string ** err_msg, casadi::CleSolver* obj){
-    try {
-
-        casadi::CleSolver ret = obj->clone();
-        return WrapReturn< casadi::CleSolver*, casadi::CleSolver >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver::doc"
-// cWrapperName: "casadi__CleSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CleSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::CleSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__CleSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__CleSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::CleSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver::hasPlugin"
-// cWrapperName: "casadi__CleSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__CleSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::CleSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__CleSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__CleSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::CleSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver::loadPlugin"
-// cWrapperName: "casadi__CleSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CleSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::CleSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__CleSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__CleSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::CleSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printStats" ===============
-// class: "casadi::CleSolver"
-// cppName: "casadi::CleSolver::printStats"
-// cWrapperName: "casadi__CleSolver__printStats"
-// protoArgs: "(std::string ** err_msg, casadi::CleSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CleSolver__printStats(std::string ** err_msg, casadi::CleSolver* obj)"
-// call: "obj->printStats()"
-// params: []
-extern "C"
-void
-    casadi__CleSolver__printStats(std::string ** err_msg, casadi::CleSolver* obj);
-void
-    casadi__CleSolver__printStats(std::string ** err_msg, casadi::CleSolver* obj){
-    try {
-
-        obj->printStats();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "CodeGenerator")===============
-// classType: UserType (Namespace ["casadi"]) (Name "CodeGenerator")
-extern "C"
-void delete_casadi__CodeGenerator(casadi::CodeGenerator* obj);
-void delete_casadi__CodeGenerator(casadi::CodeGenerator* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator"
-// cWrapperName: "casadi__CodeGenerator__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "CodeGenerator")
-// cWrapperRetType: "casadi::CodeGenerator*"
-// proto: "casadi::CodeGenerator*\n    casadi__CodeGenerator__CONSTRUCTOR__0(std::string ** err_msg)"
-// call: "casadi::CodeGenerator()"
-// params: []
-extern "C"
-casadi::CodeGenerator*
-    casadi__CodeGenerator__CONSTRUCTOR__0(std::string ** err_msg);
-casadi::CodeGenerator*
-    casadi__CodeGenerator__CONSTRUCTOR__0(std::string ** err_msg){
-    try {
-
-        return new casadi::CodeGenerator();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator"
-// cWrapperName: "casadi__CodeGenerator__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CodeGenerator")
-// cWrapperRetType: "casadi::CodeGenerator*"
-// proto: "casadi::CodeGenerator*\n    casadi__CodeGenerator__CONSTRUCTOR__1(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
-// call: "casadi::CodeGenerator(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::CodeGenerator*
-    casadi__CodeGenerator__CONSTRUCTOR__1(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0);
-casadi::CodeGenerator*
-    casadi__CodeGenerator__CONSTRUCTOR__1(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0){
-    try {
-        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
-
-        return new casadi::CodeGenerator(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::add"
-// cWrapperName: "casadi__CodeGenerator__add__0"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CodeGenerator__add__0(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0, std::string* x1)"
-// call: "obj->add(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__CodeGenerator__add__0(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0, std::string* x1);
-void
-    casadi__CodeGenerator__add__0(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0, std::string* x1){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->add(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::add"
-// cWrapperName: "casadi__CodeGenerator__add__1"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CodeGenerator__add__1(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0)"
-// call: "obj->add(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-void
-    casadi__CodeGenerator__add__1(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0);
-void
-    casadi__CodeGenerator__add__1(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-
-        obj->add(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "addInclude" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::addInclude"
-// cWrapperName: "casadi__CodeGenerator__addInclude__0"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CodeGenerator__addInclude__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
-// call: "obj->addInclude(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__CodeGenerator__addInclude__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0);
-void
-    casadi__CodeGenerator__addInclude__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->addInclude(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "addInclude" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::addInclude"
-// cWrapperName: "casadi__CodeGenerator__addInclude__1"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CodeGenerator__addInclude__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1)"
-// call: "obj->addInclude(x0_, x1_)"
-// params: [Ref (Const StdString),CBool]
-extern "C"
-void
-    casadi__CodeGenerator__addInclude__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1);
-void
-    casadi__CodeGenerator__addInclude__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->addInclude(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "addInclude" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::addInclude"
-// cWrapperName: "casadi__CodeGenerator__addInclude__2"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CodeGenerator__addInclude__2(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2)"
-// call: "obj->addInclude(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CBool,Ref (Const StdString)]
-extern "C"
-void
-    casadi__CodeGenerator__addInclude__2(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2);
-void
-    casadi__CodeGenerator__addInclude__2(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
-
-        obj->addInclude(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "compile" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::compile"
-// cWrapperName: "casadi__CodeGenerator__compile__0"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CodeGenerator__compile__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
-// call: "obj->compile(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__CodeGenerator__compile__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0);
-std::string*
-    casadi__CodeGenerator__compile__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = obj->compile(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "compile" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::compile"
-// cWrapperName: "casadi__CodeGenerator__compile__1"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CodeGenerator__compile__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1)"
-// call: "obj->compile(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__CodeGenerator__compile__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1);
-std::string*
-    casadi__CodeGenerator__compile__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        std::string ret = obj->compile(x0_, x1_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "generate" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::generate"
-// cWrapperName: "casadi__CodeGenerator__generate__0"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__CodeGenerator__generate__0(std::string ** err_msg, casadi::CodeGenerator* obj)"
-// call: "obj->generate()"
-// params: []
-extern "C"
-std::string*
-    casadi__CodeGenerator__generate__0(std::string ** err_msg, casadi::CodeGenerator* obj);
-std::string*
-    casadi__CodeGenerator__generate__0(std::string ** err_msg, casadi::CodeGenerator* obj){
-    try {
-
-        std::string ret = obj->generate();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "generate" ===============
-// class: "casadi::CodeGenerator"
-// cppName: "casadi::CodeGenerator::generate"
-// cWrapperName: "casadi__CodeGenerator__generate__1"
-// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__CodeGenerator__generate__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
-// call: "obj->generate(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__CodeGenerator__generate__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0);
-void
-    casadi__CodeGenerator__generate__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->generate(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Compiler")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Compiler")
-extern "C"
-void delete_casadi__Compiler(casadi::Compiler* obj);
-void delete_casadi__Compiler(casadi::Compiler* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Compiler"
-// cppName: "casadi::Compiler"
-// cWrapperName: "casadi__Compiler__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Compiler")
-// cWrapperRetType: "casadi::Compiler*"
-// proto: "casadi::Compiler*\n    casadi__Compiler__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1)"
-// call: "casadi::Compiler(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::Compiler*
-    casadi__Compiler__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1);
-casadi::Compiler*
-    casadi__Compiler__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        return new casadi::Compiler(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Compiler"
-// cppName: "casadi::Compiler"
-// cWrapperName: "casadi__Compiler__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Compiler")
-// cWrapperRetType: "casadi::Compiler*"
-// proto: "casadi::Compiler*\n    casadi__Compiler__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2)"
-// call: "casadi::Compiler(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Compiler*
-    casadi__Compiler__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2);
-casadi::Compiler*
-    casadi__Compiler__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
-
-        return new casadi::Compiler(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Compiler"
-// cppName: "casadi::Compiler"
-// cWrapperName: "casadi__Compiler__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Compiler")
-// cWrapperRetType: "casadi::Compiler*"
-// proto: "casadi::Compiler*\n    casadi__Compiler__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::Compiler()"
-// params: []
-extern "C"
-casadi::Compiler*
-    casadi__Compiler__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::Compiler*
-    casadi__Compiler__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::Compiler();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::Compiler"
-// cppName: "casadi::Compiler::doc"
-// cWrapperName: "casadi__Compiler__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Compiler__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Compiler::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__Compiler__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__Compiler__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::Compiler::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::Compiler"
-// cppName: "casadi::Compiler::hasPlugin"
-// cWrapperName: "casadi__Compiler__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Compiler__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Compiler::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__Compiler__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__Compiler__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::Compiler::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::Compiler"
-// cppName: "casadi::Compiler::loadPlugin"
-// cWrapperName: "casadi__Compiler__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Compiler__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Compiler::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__Compiler__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__Compiler__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Compiler::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "plugin_name" ===============
-// class: "casadi::Compiler"
-// cppName: "casadi::Compiler::plugin_name"
-// cWrapperName: "casadi__Compiler__plugin_name"
-// protoArgs: "(std::string ** err_msg, casadi::Compiler* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Compiler__plugin_name(std::string ** err_msg, casadi::Compiler* obj)"
-// call: "obj->plugin_name()"
-// params: []
-extern "C"
-std::string*
-    casadi__Compiler__plugin_name(std::string ** err_msg, casadi::Compiler* obj);
-std::string*
-    casadi__Compiler__plugin_name(std::string ** err_msg, casadi::Compiler* obj){
-    try {
-
-        std::string ret = obj->plugin_name();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "ControlSimulator")===============
-// classType: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
-extern "C"
-void delete_casadi__ControlSimulator(casadi::ControlSimulator* obj);
-void delete_casadi__ControlSimulator(casadi::ControlSimulator* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator"
-// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
-// cWrapperRetType: "casadi::ControlSimulator*"
-// proto: "casadi::ControlSimulator*\n    casadi__ControlSimulator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2)"
-// call: "casadi::ControlSimulator(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2);
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-
-        return new casadi::ControlSimulator(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator"
-// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
-// cWrapperRetType: "casadi::ControlSimulator*"
-// proto: "casadi::ControlSimulator*\n    casadi__ControlSimulator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::ControlSimulator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::ControlSimulator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator"
-// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
-// cWrapperRetType: "casadi::ControlSimulator*"
-// proto: "casadi::ControlSimulator*\n    casadi__ControlSimulator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3)"
-// call: "casadi::ControlSimulator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3);
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        casadi::DMatrix& x3_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x3);
-
-        return new casadi::ControlSimulator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator"
-// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
-// cWrapperRetType: "casadi::ControlSimulator*"
-// proto: "casadi::ControlSimulator*\n    casadi__ControlSimulator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// call: "casadi::ControlSimulator(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4);
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        casadi::DMatrix& x3_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x3);
-        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
-
-        return new casadi::ControlSimulator(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator"
-// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
-// cWrapperRetType: "casadi::ControlSimulator*"
-// proto: "casadi::ControlSimulator*\n    casadi__ControlSimulator__CONSTRUCTOR__4(std::string ** err_msg)"
-// call: "casadi::ControlSimulator()"
-// params: []
-extern "C"
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__4(std::string ** err_msg);
-casadi::ControlSimulator*
-    casadi__ControlSimulator__CONSTRUCTOR__4(std::string ** err_msg){
-    try {
-
-        return new casadi::ControlSimulator();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getMajorIndex" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator::getMajorIndex"
-// cWrapperName: "casadi__ControlSimulator__getMajorIndex"
-// protoArgs: "(std::string ** err_msg, casadi::ControlSimulator* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__ControlSimulator__getMajorIndex(std::string ** err_msg, casadi::ControlSimulator* obj)"
-// call: "obj->getMajorIndex()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__ControlSimulator__getMajorIndex(std::string ** err_msg, casadi::ControlSimulator* obj);
-std::vector< int >*
-    casadi__ControlSimulator__getMajorIndex(std::string ** err_msg, casadi::ControlSimulator* obj){
-    try {
-
-        std::vector< int > ret = obj->getMajorIndex();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getMinorT" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator::getMinorT"
-// cWrapperName: "casadi__ControlSimulator__getMinorT"
-// protoArgs: "(std::string ** err_msg, casadi::ControlSimulator* obj)"
-// args: "()"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__ControlSimulator__getMinorT(std::string ** err_msg, casadi::ControlSimulator* obj)"
-// call: "obj->getMinorT()"
-// params: []
-extern "C"
-std::vector< double >*
-    casadi__ControlSimulator__getMinorT(std::string ** err_msg, casadi::ControlSimulator* obj);
-std::vector< double >*
-    casadi__ControlSimulator__getMinorT(std::string ** err_msg, casadi::ControlSimulator* obj){
-    try {
-
-        std::vector< double > ret = obj->getMinorT();
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getMinorU" ===============
-// class: "casadi::ControlSimulator"
-// cppName: "casadi::ControlSimulator::getMinorU"
-// cWrapperName: "casadi__ControlSimulator__getMinorU"
-// protoArgs: "(std::string ** err_msg, casadi::ControlSimulator* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__ControlSimulator__getMinorU(std::string ** err_msg, casadi::ControlSimulator* obj)"
-// call: "obj->getMinorU()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__ControlSimulator__getMinorU(std::string ** err_msg, casadi::ControlSimulator* obj);
-casadi::DMatrix*
-    casadi__ControlSimulator__getMinorU(std::string ** err_msg, casadi::ControlSimulator* obj){
-    try {
-
-        casadi::DMatrix ret = obj->getMinorU();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "CustomEvaluate")===============
-// classType: UserType (Namespace ["casadi"]) (Name "CustomEvaluate")
-extern "C"
-void delete_casadi__CustomEvaluate(casadi::CustomEvaluate* obj);
-void delete_casadi__CustomEvaluate(casadi::CustomEvaluate* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomEvaluate"
-// cppName: "casadi::CustomEvaluate"
-// cWrapperName: "casadi__CustomEvaluate__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomEvaluate")
-// cWrapperRetType: "casadi::CustomEvaluate*"
-// proto: "casadi::CustomEvaluate*\n    casadi__CustomEvaluate__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::CustomEvaluate()"
-// params: []
-extern "C"
-casadi::CustomEvaluate*
-    casadi__CustomEvaluate__CONSTRUCTOR(std::string ** err_msg);
-casadi::CustomEvaluate*
-    casadi__CustomEvaluate__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::CustomEvaluate();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "CustomFunction")===============
-// classType: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-extern "C"
-void delete_casadi__CustomFunction(casadi::CustomFunction* obj);
-void delete_casadi__CustomFunction(casadi::CustomFunction* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString)))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x3_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x3);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x3_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x3);
-        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString)))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::vector< casadi::Sparsity > x2_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x2);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x3_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x3);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x3, std::map< std::string, casadi::GenericType* >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::vector< casadi::Sparsity > x2_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x2);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x3_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x3);
-        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::vector< casadi::Sparsity > x3_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x3);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))) (StdVec StdString))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::Sparsity >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::Sparsity* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::vector< casadi::Sparsity > x3_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x3);
-        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::vector< casadi::Sparsity > x2_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x2);
-        std::vector< casadi::Sparsity > x3_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x3);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// call: "casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, casadi::CustomEvaluate* x1, std::vector< casadi::Sparsity* >* x2, std::vector< casadi::Sparsity* >* x3, std::map< std::string, casadi::GenericType* >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::CustomEvaluate& x1_ = Marshaling<casadi::CustomEvaluate&,casadi::CustomEvaluate*>::marshal(x1);
-        std::vector< casadi::Sparsity > x2_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x2);
-        std::vector< casadi::Sparsity > x3_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x3);
-        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
-
-        return new casadi::CustomFunction(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::CustomFunction"
-// cppName: "casadi::CustomFunction"
-// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__8"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
-// cWrapperRetType: "casadi::CustomFunction*"
-// proto: "casadi::CustomFunction*\n    casadi__CustomFunction__CONSTRUCTOR__8(std::string ** err_msg)"
-// call: "casadi::CustomFunction()"
-// params: []
-extern "C"
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__8(std::string ** err_msg);
-casadi::CustomFunction*
-    casadi__CustomFunction__CONSTRUCTOR__8(std::string ** err_msg){
-    try {
-
-        return new casadi::CustomFunction();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "DMatrix")===============
-// classType: UserType (Namespace ["casadi"]) (Name "DMatrix")
-extern "C"
-void delete_casadi__DMatrix(casadi::DMatrix* obj);
-void delete_casadi__DMatrix(casadi::DMatrix* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::DMatrix(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        return new casadi::DMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__1(std::string ** err_msg, casadi::IMatrix* x0)"
-// call: "casadi::DMatrix(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__1(std::string ** err_msg, casadi::IMatrix* x0);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__1(std::string ** err_msg, casadi::IMatrix* x0){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-
-        return new casadi::DMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__2(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
-// call: "casadi::DMatrix(x0_)"
-// params: [Ref (Const (StdVec (StdVec CDouble)))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__2(std::string ** err_msg, std::vector< std::vector< double >* >* x0);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__2(std::string ** err_msg, std::vector< std::vector< double >* >* x0){
-    try {
-        std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);
-
-        return new casadi::DMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, double x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__3(std::string ** err_msg, double x0)"
-// call: "casadi::DMatrix(x0_)"
-// params: [CDouble]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__3(std::string ** err_msg, double x0);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__3(std::string ** err_msg, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        return new casadi::DMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1)"
-// call: "casadi::DMatrix(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::DMatrix& x1_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x1);
-
-        return new casadi::DMatrix(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::DMatrix(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        return new casadi::DMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::DMatrix(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        return new casadi::DMatrix(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::DMatrix* x0)"
-// call: "casadi::DMatrix(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::DMatrix* x0);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        return new casadi::DMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix"
-// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__8"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__CONSTRUCTOR__8(std::string ** err_msg)"
-// call: "casadi::DMatrix()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__8(std::string ** err_msg);
-casadi::DMatrix*
-    casadi__DMatrix__CONSTRUCTOR__8(std::string ** err_msg){
-    try {
-
-        return new casadi::DMatrix();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "T" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::T"
-// cWrapperName: "casadi__DMatrix__T"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__T(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->T()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__T(std::string ** err_msg, casadi::DMatrix* obj);
-casadi::DMatrix*
-    casadi__DMatrix__T(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        casadi::DMatrix ret = obj->T();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "__nonzero__" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::__nonzero__"
-// cWrapperName: "casadi__DMatrix____nonzero__"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix____nonzero__(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->__nonzero__()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix____nonzero__(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix____nonzero__(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->__nonzero__();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "append" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::append"
-// cWrapperName: "casadi__DMatrix__append"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__append(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// call: "obj->append(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__append(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
-void
-    casadi__DMatrix__append(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        obj->append(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "appendColumns" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::appendColumns"
-// cWrapperName: "casadi__DMatrix__appendColumns"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__appendColumns(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// call: "obj->appendColumns(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__appendColumns(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
-void
-    casadi__DMatrix__appendColumns(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        obj->appendColumns(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "binary" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::binary"
-// cWrapperName: "casadi__DMatrix__binary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__binary(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// call: "casadi::DMatrix::binary(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__binary(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2);
-casadi::DMatrix*
-    casadi__DMatrix__binary(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::DMatrix& x1_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-
-        casadi::DMatrix ret = casadi::DMatrix::binary(x0_, x1_, x2_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "className" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::className"
-// cWrapperName: "casadi__DMatrix__className"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DMatrix__className(std::string ** err_msg)"
-// call: "casadi::DMatrix::className()"
-// params: []
-extern "C"
-std::string*
-    casadi__DMatrix__className(std::string ** err_msg);
-std::string*
-    casadi__DMatrix__className(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::DMatrix::className();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clear" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::clear"
-// cWrapperName: "casadi__DMatrix__clear"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__clear(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->clear()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__clear(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__clear(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->clear();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "colind" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::colind"
-// cWrapperName: "casadi__DMatrix__colind"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__colind(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->colind(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__DMatrix__colind(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-int
-    casadi__DMatrix__colind(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->colind(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "dimString" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::dimString"
-// cWrapperName: "casadi__DMatrix__dimString"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DMatrix__dimString(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->dimString()"
-// params: []
-extern "C"
-std::string*
-    casadi__DMatrix__dimString(std::string ** err_msg, casadi::DMatrix* obj);
-std::string*
-    casadi__DMatrix__dimString(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::string ret = obj->dimString();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::enlarge"
-// cWrapperName: "casadi__DMatrix__enlarge__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__enlarge__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__DMatrix__enlarge__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-void
-    casadi__DMatrix__enlarge__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        obj->enlarge(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::enlarge"
-// cWrapperName: "casadi__DMatrix__enlarge__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__enlarge__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_, x4_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__DMatrix__enlarge__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
-void
-    casadi__DMatrix__enlarge__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::erase"
-// cWrapperName: "casadi__DMatrix__erase__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__erase__0(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0)"
-// call: "obj->erase(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__DMatrix__erase__0(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0);
-void
-    casadi__DMatrix__erase__0(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        obj->erase(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::erase"
-// cWrapperName: "casadi__DMatrix__erase__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__erase__1(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, int x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__DMatrix__erase__1(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, int x1);
-void
-    casadi__DMatrix__erase__1(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::erase"
-// cWrapperName: "casadi__DMatrix__erase__2"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__erase__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__DMatrix__erase__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__DMatrix__erase__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::erase"
-// cWrapperName: "casadi__DMatrix__erase__3"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__erase__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// call: "obj->erase(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__DMatrix__erase__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
-void
-    casadi__DMatrix__erase__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->erase(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "eye" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::eye"
-// cWrapperName: "casadi__DMatrix__eye"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__eye(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::eye(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__eye(std::string ** err_msg, int x0);
-casadi::DMatrix*
-    casadi__DMatrix__eye(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::eye(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::find"
-// cWrapperName: "casadi__DMatrix__find__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__DMatrix__find__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->find()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__DMatrix__find__0(std::string ** err_msg, casadi::DMatrix* obj);
-std::vector< int >*
-    casadi__DMatrix__find__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->find();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::find"
-// cWrapperName: "casadi__DMatrix__find__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__DMatrix__find__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->find(x0_)"
-// params: [CBool]
-extern "C"
-std::vector< int >*
-    casadi__DMatrix__find__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-std::vector< int >*
-    casadi__DMatrix__find__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        std::vector< int > ret = obj->find(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__get__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__DMatrix__get__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__get__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__DMatrix__get__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__2"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__get__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__DMatrix__get__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__3"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__get__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__DMatrix__get__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__4"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__DMatrix__get__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__DMatrix__get__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__5"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__get__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__DMatrix__get__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__6"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__get__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__DMatrix__get__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::get"
-// cWrapperName: "casadi__DMatrix__get__7"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__get__7(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// call: "obj->get(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__DMatrix__get__7(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
-void
-    casadi__DMatrix__get__7(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->get(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getColind" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getColind"
-// cWrapperName: "casadi__DMatrix__getColind"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__DMatrix__getColind(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getColind()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__DMatrix__getColind(std::string ** err_msg, casadi::DMatrix* obj);
-std::vector< int >*
-    casadi__DMatrix__getColind(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->getColind();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getDep"
-// cWrapperName: "casadi__DMatrix__getDep__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__getDep__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getDep()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__getDep__0(std::string ** err_msg, casadi::DMatrix* obj);
-casadi::DMatrix*
-    casadi__DMatrix__getDep__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        casadi::DMatrix ret = obj->getDep();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getDep"
-// cWrapperName: "casadi__DMatrix__getDep__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__getDep__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->getDep(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__getDep__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-casadi::DMatrix*
-    casadi__DMatrix__getDep__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = obj->getDep(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getElementHash" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getElementHash"
-// cWrapperName: "casadi__DMatrix__getElementHash"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__DMatrix__getElementHash(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getElementHash()"
-// params: []
-extern "C"
-size_t
-    casadi__DMatrix__getElementHash(std::string ** err_msg, casadi::DMatrix* obj);
-size_t
-    casadi__DMatrix__getElementHash(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        size_t ret = obj->getElementHash();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getEqualityCheckingDepth" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getEqualityCheckingDepth"
-// cWrapperName: "casadi__DMatrix__getEqualityCheckingDepth"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__getEqualityCheckingDepth(std::string ** err_msg)"
-// call: "casadi::DMatrix::getEqualityCheckingDepth()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__getEqualityCheckingDepth(std::string ** err_msg);
-int
-    casadi__DMatrix__getEqualityCheckingDepth(std::string ** err_msg){
-    try {
-
-        int ret = casadi::DMatrix::getEqualityCheckingDepth();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getIntValue" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getIntValue"
-// cWrapperName: "casadi__DMatrix__getIntValue"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__getIntValue(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getIntValue()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__getIntValue(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__getIntValue(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->getIntValue();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getNZ"
-// cWrapperName: "casadi__DMatrix__getNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__getNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__getNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__DMatrix__getNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getNZ"
-// cWrapperName: "casadi__DMatrix__getNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__getNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__getNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__DMatrix__getNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getNZ"
-// cWrapperName: "casadi__DMatrix__getNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__getNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// call: "obj->getNZ(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__DMatrix__getNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
-void
-    casadi__DMatrix__getNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->getNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getName" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getName"
-// cWrapperName: "casadi__DMatrix__getName"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DMatrix__getName(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getName()"
-// params: []
-extern "C"
-std::string*
-    casadi__DMatrix__getName(std::string ** err_msg, casadi::DMatrix* obj);
-std::string*
-    casadi__DMatrix__getName(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::string ret = obj->getName();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNdeps" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getNdeps"
-// cWrapperName: "casadi__DMatrix__getNdeps"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__getNdeps(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getNdeps()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__getNdeps(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__getNdeps(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->getNdeps();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRow" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getRow"
-// cWrapperName: "casadi__DMatrix__getRow"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__DMatrix__getRow(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getRow()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__DMatrix__getRow(std::string ** err_msg, casadi::DMatrix* obj);
-std::vector< int >*
-    casadi__DMatrix__getRow(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->getRow();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getSparsity" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getSparsity"
-// cWrapperName: "casadi__DMatrix__getSparsity"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__DMatrix__getSparsity(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__DMatrix__getSparsity(std::string ** err_msg, casadi::DMatrix* obj);
-casadi::Sparsity*
-    casadi__DMatrix__getSparsity(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        casadi::Sparsity ret = obj->getSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getSym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getSym"
-// cWrapperName: "casadi__DMatrix__getSym"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__getSym(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// call: "obj->getSym(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__DMatrix__getSym(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
-void
-    casadi__DMatrix__getSym(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->getSym(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getValue" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getValue"
-// cWrapperName: "casadi__DMatrix__getValue__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DMatrix__getValue__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->getValue(x0_)"
-// params: [CInt]
-extern "C"
-double
-    casadi__DMatrix__getValue__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-double
-    casadi__DMatrix__getValue__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        double ret = obj->getValue(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getValue" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getValue"
-// cWrapperName: "casadi__DMatrix__getValue__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DMatrix__getValue__1(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getValue()"
-// params: []
-extern "C"
-double
-    casadi__DMatrix__getValue__1(std::string ** err_msg, casadi::DMatrix* obj);
-double
-    casadi__DMatrix__getValue__1(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        double ret = obj->getValue();
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasDuplicates" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::hasDuplicates"
-// cWrapperName: "casadi__DMatrix__hasDuplicates"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__hasDuplicates(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->hasDuplicates()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__hasDuplicates(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__hasDuplicates(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->hasDuplicates();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::hasNZ"
-// cWrapperName: "casadi__DMatrix__hasNZ"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__hasNZ(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
-// call: "obj->hasNZ(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-int
-    casadi__DMatrix__hasNZ(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
-int
-    casadi__DMatrix__hasNZ(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        bool ret = obj->hasNZ(x0_, x1_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasNonStructuralZeros" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::hasNonStructuralZeros"
-// cWrapperName: "casadi__DMatrix__hasNonStructuralZeros"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->hasNonStructuralZeros()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->hasNonStructuralZeros();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::inf"
-// cWrapperName: "casadi__DMatrix__inf__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::DMatrix::inf(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::DMatrix*
-    casadi__DMatrix__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::inf(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::inf"
-// cWrapperName: "casadi__DMatrix__inf__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__inf__1(std::string ** err_msg)"
-// call: "casadi::DMatrix::inf()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__inf__1(std::string ** err_msg);
-casadi::DMatrix*
-    casadi__DMatrix__inf__1(std::string ** err_msg){
-    try {
-
-        casadi::DMatrix ret = casadi::DMatrix::inf();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::inf"
-// cWrapperName: "casadi__DMatrix__inf__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__inf__2(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::inf(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__inf__2(std::string ** err_msg, int x0);
-casadi::DMatrix*
-    casadi__DMatrix__inf__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::inf(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::inf"
-// cWrapperName: "casadi__DMatrix__inf__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__inf__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::DMatrix::inf(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__inf__3(std::string ** err_msg, int x0, int x1);
-casadi::DMatrix*
-    casadi__DMatrix__inf__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::inf(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::inf"
-// cWrapperName: "casadi__DMatrix__inf__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::DMatrix::inf(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::DMatrix*
-    casadi__DMatrix__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::inf(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isCommutative" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isCommutative"
-// cWrapperName: "casadi__DMatrix__isCommutative"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isCommutative(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isCommutative()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isCommutative(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isCommutative(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isCommutative();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isConstant" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isConstant"
-// cWrapperName: "casadi__DMatrix__isConstant"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isConstant(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isConstant()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isConstant(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isConstant(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isConstant();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isIdentity" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isIdentity"
-// cWrapperName: "casadi__DMatrix__isIdentity"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isIdentity(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isIdentity()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isIdentity(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isIdentity(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isIdentity();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isInteger" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isInteger"
-// cWrapperName: "casadi__DMatrix__isInteger"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isInteger(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isInteger()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isInteger(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isInteger(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isInteger();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isLeaf" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isLeaf"
-// cWrapperName: "casadi__DMatrix__isLeaf"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isLeaf(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isLeaf()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isLeaf(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isLeaf(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isLeaf();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isMinusOne" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isMinusOne"
-// cWrapperName: "casadi__DMatrix__isMinusOne"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isMinusOne(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isMinusOne()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isMinusOne(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isMinusOne(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isMinusOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isOne" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isOne"
-// cWrapperName: "casadi__DMatrix__isOne"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isOne(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isOne()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isOne(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isOne(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isRegular" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isRegular"
-// cWrapperName: "casadi__DMatrix__isRegular"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isRegular(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isRegular()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isRegular(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isRegular(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isRegular();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSlice" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isSlice"
-// cWrapperName: "casadi__DMatrix__isSlice__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isSlice__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isSlice()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isSlice__0(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isSlice__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isSlice();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSlice" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isSlice"
-// cWrapperName: "casadi__DMatrix__isSlice__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isSlice__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->isSlice(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__DMatrix__isSlice__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-int
-    casadi__DMatrix__isSlice__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isSlice(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSmooth" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isSmooth"
-// cWrapperName: "casadi__DMatrix__isSmooth"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isSmooth(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isSmooth()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isSmooth(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isSmooth(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isSmooth();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSymbolic" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isSymbolic"
-// cWrapperName: "casadi__DMatrix__isSymbolic"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isSymbolic(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isSymbolic()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isSymbolic(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isSymbolic(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isSymbolic();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isValidInput" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isValidInput"
-// cWrapperName: "casadi__DMatrix__isValidInput"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isValidInput(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isValidInput()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isValidInput(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isValidInput(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isValidInput();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isZero" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isZero"
-// cWrapperName: "casadi__DMatrix__isZero"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isZero(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isZero()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isZero(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isZero(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isZero();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "iscolumn" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::iscolumn"
-// cWrapperName: "casadi__DMatrix__iscolumn"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__iscolumn(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->iscolumn()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__iscolumn(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__iscolumn(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->iscolumn();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isdense" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isdense"
-// cWrapperName: "casadi__DMatrix__isdense"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isdense(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isdense()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isdense(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isdense(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isdense();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isempty"
-// cWrapperName: "casadi__DMatrix__isempty__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isempty__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isempty()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isempty__0(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isempty__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isempty();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isempty"
-// cWrapperName: "casadi__DMatrix__isempty__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isempty__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->isempty(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__DMatrix__isempty__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-int
-    casadi__DMatrix__isempty__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isempty(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isrow" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isrow"
-// cWrapperName: "casadi__DMatrix__isrow"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isrow(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isrow()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isrow(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isrow(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isrow();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isscalar"
-// cWrapperName: "casadi__DMatrix__isscalar__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isscalar__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isscalar()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isscalar__0(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isscalar__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isscalar();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isscalar"
-// cWrapperName: "casadi__DMatrix__isscalar__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isscalar__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->isscalar(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__DMatrix__isscalar__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-int
-    casadi__DMatrix__isscalar__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isscalar(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "issquare" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::issquare"
-// cWrapperName: "casadi__DMatrix__issquare"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__issquare(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->issquare()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__issquare(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__issquare(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->issquare();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istril" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::istril"
-// cWrapperName: "casadi__DMatrix__istril"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__istril(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->istril()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__istril(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__istril(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->istril();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istriu" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::istriu"
-// cWrapperName: "casadi__DMatrix__istriu"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__istriu(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->istriu()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__istriu(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__istriu(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->istriu();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isvector" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::isvector"
-// cWrapperName: "casadi__DMatrix__isvector"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__isvector(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->isvector()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__isvector(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__isvector(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        bool ret = obj->isvector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "makeSparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::makeSparse"
-// cWrapperName: "casadi__DMatrix__makeSparse__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__makeSparse__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->makeSparse()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__makeSparse__0(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__makeSparse__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->makeSparse();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "makeSparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::makeSparse"
-// cWrapperName: "casadi__DMatrix__makeSparse__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__makeSparse__1(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// call: "obj->makeSparse(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__DMatrix__makeSparse__1(std::string ** err_msg, casadi::DMatrix* obj, double x0);
-void
-    casadi__DMatrix__makeSparse__1(std::string ** err_msg, casadi::DMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->makeSparse(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "matrix_matrix" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::matrix_matrix"
-// cWrapperName: "casadi__DMatrix__matrix_matrix"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__matrix_matrix(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// call: "casadi::DMatrix::matrix_matrix(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__matrix_matrix(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2);
-casadi::DMatrix*
-    casadi__DMatrix__matrix_matrix(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::DMatrix& x1_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-
-        casadi::DMatrix ret = casadi::DMatrix::matrix_matrix(x0_, x1_, x2_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "matrix_scalar" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::matrix_scalar"
-// cWrapperName: "casadi__DMatrix__matrix_scalar"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__matrix_scalar(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// call: "casadi::DMatrix::matrix_scalar(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__matrix_scalar(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2);
-casadi::DMatrix*
-    casadi__DMatrix__matrix_scalar(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::DMatrix& x1_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-
-        casadi::DMatrix ret = casadi::DMatrix::matrix_scalar(x0_, x1_, x2_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nan"
-// cWrapperName: "casadi__DMatrix__nan__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::DMatrix::nan(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::DMatrix*
-    casadi__DMatrix__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::nan(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nan"
-// cWrapperName: "casadi__DMatrix__nan__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__nan__1(std::string ** err_msg)"
-// call: "casadi::DMatrix::nan()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__nan__1(std::string ** err_msg);
-casadi::DMatrix*
-    casadi__DMatrix__nan__1(std::string ** err_msg){
-    try {
-
-        casadi::DMatrix ret = casadi::DMatrix::nan();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nan"
-// cWrapperName: "casadi__DMatrix__nan__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__nan__2(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::nan(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__nan__2(std::string ** err_msg, int x0);
-casadi::DMatrix*
-    casadi__DMatrix__nan__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::nan(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nan"
-// cWrapperName: "casadi__DMatrix__nan__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__nan__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::DMatrix::nan(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__nan__3(std::string ** err_msg, int x0, int x1);
-casadi::DMatrix*
-    casadi__DMatrix__nan__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::nan(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nan"
-// cWrapperName: "casadi__DMatrix__nan__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::DMatrix::nan(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::DMatrix*
-    casadi__DMatrix__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::nan(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nnz" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nnz"
-// cWrapperName: "casadi__DMatrix__nnz"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__nnz(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->nnz()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__nnz(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__nnz(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->nnz();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nonzeros" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nonzeros"
-// cWrapperName: "casadi__DMatrix__nonzeros"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DMatrix__nonzeros(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->nonzeros()"
-// params: []
-extern "C"
-std::vector< double >*
-    casadi__DMatrix__nonzeros(std::string ** err_msg, casadi::DMatrix* obj);
-std::vector< double >*
-    casadi__DMatrix__nonzeros(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::vector< double > ret = obj->nonzeros();
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nonzeros_int" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::nonzeros_int"
-// cWrapperName: "casadi__DMatrix__nonzeros_int"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__DMatrix__nonzeros_int(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->nonzeros_int()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__DMatrix__nonzeros_int(std::string ** err_msg, casadi::DMatrix* obj);
-std::vector< int >*
-    casadi__DMatrix__nonzeros_int(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->nonzeros_int();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::numel"
-// cWrapperName: "casadi__DMatrix__numel__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__numel__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->numel(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__DMatrix__numel__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-int
-    casadi__DMatrix__numel__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->numel(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::numel"
-// cWrapperName: "casadi__DMatrix__numel__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__numel__1(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->numel()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__numel__1(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__numel__1(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->numel();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::ones"
-// cWrapperName: "casadi__DMatrix__ones__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::DMatrix::ones(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::DMatrix*
-    casadi__DMatrix__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::ones(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::ones"
-// cWrapperName: "casadi__DMatrix__ones__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::DMatrix::ones(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::DMatrix*
-    casadi__DMatrix__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::ones(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::ones"
-// cWrapperName: "casadi__DMatrix__ones__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__ones__2(std::string ** err_msg)"
-// call: "casadi::DMatrix::ones()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__ones__2(std::string ** err_msg);
-casadi::DMatrix*
-    casadi__DMatrix__ones__2(std::string ** err_msg){
-    try {
-
-        casadi::DMatrix ret = casadi::DMatrix::ones();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::ones"
-// cWrapperName: "casadi__DMatrix__ones__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__ones__3(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::ones(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__ones__3(std::string ** err_msg, int x0);
-casadi::DMatrix*
-    casadi__DMatrix__ones__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::ones(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::ones"
-// cWrapperName: "casadi__DMatrix__ones__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__ones__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::DMatrix::ones(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__ones__4(std::string ** err_msg, int x0, int x1);
-casadi::DMatrix*
-    casadi__DMatrix__ones__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::ones(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator +" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::operator +"
-// cWrapperName: "casadi__DMatrix__operator_plus"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__operator_plus(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->operator +()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__operator_plus(std::string ** err_msg, casadi::DMatrix* obj);
-casadi::DMatrix*
-    casadi__DMatrix__operator_plus(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        casadi::DMatrix ret = obj->operator +();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator -" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::operator -"
-// cWrapperName: "casadi__DMatrix__operator_minus"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__operator_minus(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->operator -()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__operator_minus(std::string ** err_msg, casadi::DMatrix* obj);
-casadi::DMatrix*
-    casadi__DMatrix__operator_minus(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        casadi::DMatrix ret = obj->operator -();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "printDense" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::printDense"
-// cWrapperName: "casadi__DMatrix__printDense"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__printDense(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->printDense()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__printDense(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__printDense(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->printDense();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printScalar" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::printScalar"
-// cWrapperName: "casadi__DMatrix__printScalar"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__printScalar(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->printScalar()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__printScalar(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__printScalar(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->printScalar();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printSparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::printSparse"
-// cWrapperName: "casadi__DMatrix__printSparse"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__printSparse(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->printSparse()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__printSparse(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__printSparse(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->printSparse();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printSplit" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::printSplit"
-// cWrapperName: "casadi__DMatrix__printSplit"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__printSplit(std::string ** err_msg, casadi::DMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
-// call: "obj->printSplit(x0_, x1_)"
-// params: [Ref (StdVec StdString),Ref (StdVec StdString)]
-extern "C"
-void
-    casadi__DMatrix__printSplit(std::string ** err_msg, casadi::DMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1);
-void
-    casadi__DMatrix__printSplit(std::string ** err_msg, casadi::DMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1){
-    try {
-        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);
-        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);
-
-        obj->printSplit(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printVector" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::printVector"
-// cWrapperName: "casadi__DMatrix__printVector"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__printVector(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->printVector()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__printVector(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__printVector(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->printVector();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printme" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::printme"
-// cWrapperName: "casadi__DMatrix__printme"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__printme(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// call: "obj->printme(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__printme(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
-casadi::DMatrix*
-    casadi__DMatrix__printme(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        casadi::DMatrix ret = obj->printme(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "remove" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::remove"
-// cWrapperName: "casadi__DMatrix__remove"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__remove(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->remove(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__DMatrix__remove(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__DMatrix__remove(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->remove(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reserve" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::reserve"
-// cWrapperName: "casadi__DMatrix__reserve__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__reserve__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
-// call: "obj->reserve(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__DMatrix__reserve__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
-void
-    casadi__DMatrix__reserve__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->reserve(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reserve" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::reserve"
-// cWrapperName: "casadi__DMatrix__reserve__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__reserve__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->reserve(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__DMatrix__reserve__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-void
-    casadi__DMatrix__reserve__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        obj->reserve(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resetInput" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::resetInput"
-// cWrapperName: "casadi__DMatrix__resetInput"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__resetInput(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->resetInput()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__resetInput(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__resetInput(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->resetInput();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resize" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::resize"
-// cWrapperName: "casadi__DMatrix__resize"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__resize(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
-// call: "obj->resize(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__DMatrix__resize(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
-void
-    casadi__DMatrix__resize(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->resize(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "row" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::row"
-// cWrapperName: "casadi__DMatrix__row"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__row(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->row(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__DMatrix__row(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-int
-    casadi__DMatrix__row(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->row(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sanityCheck"
-// cWrapperName: "casadi__DMatrix__sanityCheck__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__sanityCheck__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->sanityCheck()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__sanityCheck__0(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__sanityCheck__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->sanityCheck();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sanityCheck"
-// cWrapperName: "casadi__DMatrix__sanityCheck__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__sanityCheck__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->sanityCheck(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__DMatrix__sanityCheck__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-void
-    casadi__DMatrix__sanityCheck__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->sanityCheck(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "scalar_matrix" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::scalar_matrix"
-// cWrapperName: "casadi__DMatrix__scalar_matrix"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__scalar_matrix(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2)"
-// call: "casadi::DMatrix::scalar_matrix(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__scalar_matrix(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2);
-casadi::DMatrix*
-    casadi__DMatrix__scalar_matrix(std::string ** err_msg, int x0, casadi::DMatrix* x1, casadi::DMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::DMatrix& x1_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-
-        casadi::DMatrix ret = casadi::DMatrix::scalar_matrix(x0_, x1_, x2_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__set__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__DMatrix__set__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__set__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__DMatrix__set__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__2"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__set__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__DMatrix__set__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__3"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__set__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__DMatrix__set__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__4"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__DMatrix__set__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__DMatrix__set__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__5"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__set__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__DMatrix__set__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__6"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__set__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__DMatrix__set__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__7"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__7(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// call: "obj->set(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DMatrix__set__7(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
-void
-    casadi__DMatrix__set__7(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__8"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__8(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1)"
-// call: "obj->set(x0_, x1_)"
-// params: [Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__DMatrix__set__8(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1);
-void
-    casadi__DMatrix__set__8(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->set(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__9"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__9(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// call: "obj->set(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__DMatrix__set__9(std::string ** err_msg, casadi::DMatrix* obj, double x0);
-void
-    casadi__DMatrix__set__9(std::string ** err_msg, casadi::DMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::set"
-// cWrapperName: "casadi__DMatrix__set__10"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__set__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
-// call: "obj->set(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__set__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
-void
-    casadi__DMatrix__set__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setEqualityCheckingDepth"
-// cWrapperName: "casadi__DMatrix__setEqualityCheckingDepth__0"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setEqualityCheckingDepth__0(std::string ** err_msg)"
-// call: "casadi::DMatrix::setEqualityCheckingDepth()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__setEqualityCheckingDepth__0(std::string ** err_msg);
-void
-    casadi__DMatrix__setEqualityCheckingDepth__0(std::string ** err_msg){
-    try {
-
-        casadi::DMatrix::setEqualityCheckingDepth();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setEqualityCheckingDepth"
-// cWrapperName: "casadi__DMatrix__setEqualityCheckingDepth__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::setEqualityCheckingDepth(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__DMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
-void
-    casadi__DMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix::setEqualityCheckingDepth(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setNZ"
-// cWrapperName: "casadi__DMatrix__setNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__DMatrix__setNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__DMatrix__setNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setNZ"
-// cWrapperName: "casadi__DMatrix__setNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__DMatrix__setNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__DMatrix__setNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setNZ"
-// cWrapperName: "casadi__DMatrix__setNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// call: "obj->setNZ(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DMatrix__setNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
-void
-    casadi__DMatrix__setNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->setNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setNZ"
-// cWrapperName: "casadi__DMatrix__setNZ__3"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setNZ__3(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// call: "obj->setNZ(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__DMatrix__setNZ__3(std::string ** err_msg, casadi::DMatrix* obj, double x0);
-void
-    casadi__DMatrix__setNZ__3(std::string ** err_msg, casadi::DMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->setNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setPrecision" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setPrecision"
-// cWrapperName: "casadi__DMatrix__setPrecision"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setPrecision(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::setPrecision(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__DMatrix__setPrecision(std::string ** err_msg, int x0);
-void
-    casadi__DMatrix__setPrecision(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix::setPrecision(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setScientific" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setScientific"
-// cWrapperName: "casadi__DMatrix__setScientific"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setScientific(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::setScientific(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__DMatrix__setScientific(std::string ** err_msg, int x0);
-void
-    casadi__DMatrix__setScientific(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::DMatrix::setScientific(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setSym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setSym"
-// cWrapperName: "casadi__DMatrix__setSym"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setSym(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
-// call: "obj->setSym(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DMatrix__setSym(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
-void
-    casadi__DMatrix__setSym(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->setSym(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setValue" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setValue"
-// cWrapperName: "casadi__DMatrix__setValue__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setValue__0(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1)"
-// call: "obj->setValue(x0_, x1_)"
-// params: [CDouble,CInt]
-extern "C"
-void
-    casadi__DMatrix__setValue__0(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1);
-void
-    casadi__DMatrix__setValue__0(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setValue(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setValue" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setValue"
-// cWrapperName: "casadi__DMatrix__setValue__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setValue__1(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
-// call: "obj->setValue(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__DMatrix__setValue__1(std::string ** err_msg, casadi::DMatrix* obj, double x0);
-void
-    casadi__DMatrix__setValue__1(std::string ** err_msg, casadi::DMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->setValue(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setWidth" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setWidth"
-// cWrapperName: "casadi__DMatrix__setWidth"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setWidth(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::setWidth(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__DMatrix__setWidth(std::string ** err_msg, int x0);
-void
-    casadi__DMatrix__setWidth(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix::setWidth(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setZero" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::setZero"
-// cWrapperName: "casadi__DMatrix__setZero"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DMatrix__setZero(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->setZero()"
-// params: []
-extern "C"
-void
-    casadi__DMatrix__setZero(std::string ** err_msg, casadi::DMatrix* obj);
-void
-    casadi__DMatrix__setZero(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        obj->setZero();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::shape"
-// cWrapperName: "casadi__DMatrix__shape__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__shape__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->shape(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__DMatrix__shape__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-int
-    casadi__DMatrix__shape__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->shape(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::shape"
-// cWrapperName: "casadi__DMatrix__shape__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__DMatrix__shape__1(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->shape()"
-// params: []
-extern "C"
-std::pair< int, int >*
-    casadi__DMatrix__shape__1(std::string ** err_msg, casadi::DMatrix* obj);
-std::pair< int, int >*
-    casadi__DMatrix__shape__1(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::pair< int, int > ret = obj->shape();
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::size"
-// cWrapperName: "casadi__DMatrix__size"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__size(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->size()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__size(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__size(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->size();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size1" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::size1"
-// cWrapperName: "casadi__DMatrix__size1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__size1(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->size1()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__size1(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__size1(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->size1();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size2" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::size2"
-// cWrapperName: "casadi__DMatrix__size2"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__size2(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->size2()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__size2(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__size2(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->size2();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeD" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sizeD"
-// cWrapperName: "casadi__DMatrix__sizeD"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__sizeD(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->sizeD()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__sizeD(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__sizeD(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->sizeD();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeL" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sizeL"
-// cWrapperName: "casadi__DMatrix__sizeL"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__sizeL(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->sizeL()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__sizeL(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__sizeL(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->sizeL();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeU" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sizeU"
-// cWrapperName: "casadi__DMatrix__sizeU"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DMatrix__sizeU(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->sizeU()"
-// params: []
-extern "C"
-int
-    casadi__DMatrix__sizeU(std::string ** err_msg, casadi::DMatrix* obj);
-int
-    casadi__DMatrix__sizeU(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        int ret = obj->sizeU();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sparse"
-// cWrapperName: "casadi__DMatrix__sparse__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1)"
-// call: "casadi::DMatrix::sparse(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1);
-casadi::DMatrix*
-    casadi__DMatrix__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::DMatrix* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::DMatrix& x1_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::sparse(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sparse"
-// cWrapperName: "casadi__DMatrix__sparse__1"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sparse__1(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::DMatrix::sparse(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sparse__1(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::DMatrix*
-    casadi__DMatrix__sparse__1(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::sparse(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sparse"
-// cWrapperName: "casadi__DMatrix__sparse__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sparse__2(std::string ** err_msg)"
-// call: "casadi::DMatrix::sparse()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sparse__2(std::string ** err_msg);
-casadi::DMatrix*
-    casadi__DMatrix__sparse__2(std::string ** err_msg){
-    try {
-
-        casadi::DMatrix ret = casadi::DMatrix::sparse();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sparse"
-// cWrapperName: "casadi__DMatrix__sparse__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sparse__3(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::sparse(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sparse__3(std::string ** err_msg, int x0);
-casadi::DMatrix*
-    casadi__DMatrix__sparse__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::sparse(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sparse"
-// cWrapperName: "casadi__DMatrix__sparse__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sparse__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::DMatrix::sparse(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sparse__4(std::string ** err_msg, int x0, int x1);
-casadi::DMatrix*
-    casadi__DMatrix__sparse__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::sparse(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sparsity" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sparsity"
-// cWrapperName: "casadi__DMatrix__sparsity"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__DMatrix__sparsity(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->sparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__DMatrix__sparsity(std::string ** err_msg, casadi::DMatrix* obj);
-casadi::Sparsity*
-    casadi__DMatrix__sparsity(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        casadi::Sparsity ret = obj->sparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
-// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
-// proto: "std::vector< std::vector< casadi::DMatrix* >* >*\n    casadi__DMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// call: "casadi::DMatrix::sym(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::DMatrix* >* >*
-    casadi__DMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
-std::vector< std::vector< casadi::DMatrix* >* >*
-    casadi__DMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        std::vector< std::vector< casadi::DMatrix > > ret = casadi::DMatrix::sym(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< std::vector< std::vector< casadi::DMatrix* >* >*, std::vector< std::vector< casadi::DMatrix > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
-// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
-// proto: "std::vector< std::vector< casadi::DMatrix* >* >*\n    casadi__DMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// call: "casadi::DMatrix::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::DMatrix* >* >*
-    casadi__DMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
-std::vector< std::vector< casadi::DMatrix* >* >*
-    casadi__DMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< std::vector< casadi::DMatrix > > ret = casadi::DMatrix::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< std::vector< casadi::DMatrix* >* >*, std::vector< std::vector< casadi::DMatrix > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
-// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
-// proto: "std::vector< casadi::DMatrix* >*\n    casadi__DMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// call: "casadi::DMatrix::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt]
-extern "C"
-std::vector< casadi::DMatrix* >*
-    casadi__DMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
-std::vector< casadi::DMatrix* >*
-    casadi__DMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< casadi::DMatrix > ret = casadi::DMatrix::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
-// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
-// proto: "std::vector< casadi::DMatrix* >*\n    casadi__DMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// call: "casadi::DMatrix::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
-extern "C"
-std::vector< casadi::DMatrix* >*
-    casadi__DMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
-std::vector< casadi::DMatrix* >*
-    casadi__DMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        std::vector< casadi::DMatrix > ret = casadi::DMatrix::sym(x0_, x1_, x2_);
-        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// call: "casadi::DMatrix::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
-casadi::DMatrix*
-    casadi__DMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::sym(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// call: "casadi::DMatrix::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
-casadi::DMatrix*
-    casadi__DMatrix__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::sym(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sym__6(std::string ** err_msg, std::string* x0)"
-// call: "casadi::DMatrix::sym(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sym__6(std::string ** err_msg, std::string* x0);
-casadi::DMatrix*
-    casadi__DMatrix__sym__6(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::sym(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sym__7(std::string ** err_msg, std::string* x0, int x1)"
-// call: "casadi::DMatrix::sym(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sym__7(std::string ** err_msg, std::string* x0, int x1);
-casadi::DMatrix*
-    casadi__DMatrix__sym__7(std::string ** err_msg, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::sym(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::sym"
-// cWrapperName: "casadi__DMatrix__sym__8"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// call: "casadi::DMatrix::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
-casadi::DMatrix*
-    casadi__DMatrix__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        casadi::DMatrix ret = casadi::DMatrix::sym(x0_, x1_, x2_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toSlice" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::toSlice"
-// cWrapperName: "casadi__DMatrix__toSlice__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__DMatrix__toSlice__0(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->toSlice()"
-// params: []
-extern "C"
-casadi::Slice*
-    casadi__DMatrix__toSlice__0(std::string ** err_msg, casadi::DMatrix* obj);
-casadi::Slice*
-    casadi__DMatrix__toSlice__0(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        casadi::Slice ret = obj->toSlice();
-        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toSlice" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::toSlice"
-// cWrapperName: "casadi__DMatrix__toSlice__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__DMatrix__toSlice__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
-// call: "obj->toSlice(x0_)"
-// params: [CBool]
-extern "C"
-casadi::Slice*
-    casadi__DMatrix__toSlice__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
-casadi::Slice*
-    casadi__DMatrix__toSlice__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::Slice ret = obj->toSlice(x0_);
-        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::triplet"
-// cWrapperName: "casadi__DMatrix__triplet__0"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, std::pair< int, int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, std::pair< int, int >* x3)"
-// call: "casadi::DMatrix::triplet(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, std::pair< int, int >* x3);
-casadi::DMatrix*
-    casadi__DMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, std::pair< int, int >* x3){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-        std::pair< int, int > x3_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x3);
-
-        casadi::DMatrix ret = casadi::DMatrix::triplet(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::triplet"
-// cWrapperName: "casadi__DMatrix__triplet__1"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, int x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, int x3, int x4)"
-// call: "casadi::DMatrix::triplet(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, int x3, int x4);
-casadi::DMatrix*
-    casadi__DMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2, int x3, int x4){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        casadi::DMatrix ret = casadi::DMatrix::triplet(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::triplet"
-// cWrapperName: "casadi__DMatrix__triplet__2"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2)"
-// call: "casadi::DMatrix::triplet(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2);
-casadi::DMatrix*
-    casadi__DMatrix__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DMatrix* x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-
-        casadi::DMatrix ret = casadi::DMatrix::triplet(x0_, x1_, x2_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "unary" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::unary"
-// cWrapperName: "casadi__DMatrix__unary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::DMatrix* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__unary(std::string ** err_msg, int x0, casadi::DMatrix* x1)"
-// call: "casadi::DMatrix::unary(x0_, x1_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__unary(std::string ** err_msg, int x0, casadi::DMatrix* x1);
-casadi::DMatrix*
-    casadi__DMatrix__unary(std::string ** err_msg, int x0, casadi::DMatrix* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::DMatrix& x1_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::unary(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::zeros"
-// cWrapperName: "casadi__DMatrix__zeros__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::DMatrix::zeros(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::DMatrix*
-    casadi__DMatrix__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::zeros(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::zeros"
-// cWrapperName: "casadi__DMatrix__zeros__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::DMatrix::zeros(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::DMatrix*
-    casadi__DMatrix__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::zeros(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::zeros"
-// cWrapperName: "casadi__DMatrix__zeros__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__zeros__2(std::string ** err_msg)"
-// call: "casadi::DMatrix::zeros()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__zeros__2(std::string ** err_msg);
-casadi::DMatrix*
-    casadi__DMatrix__zeros__2(std::string ** err_msg){
-    try {
-
-        casadi::DMatrix ret = casadi::DMatrix::zeros();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::zeros"
-// cWrapperName: "casadi__DMatrix__zeros__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__zeros__3(std::string ** err_msg, int x0)"
-// call: "casadi::DMatrix::zeros(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__zeros__3(std::string ** err_msg, int x0);
-casadi::DMatrix*
-    casadi__DMatrix__zeros__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = casadi::DMatrix::zeros(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::zeros"
-// cWrapperName: "casadi__DMatrix__zeros__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__DMatrix__zeros__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::DMatrix::zeros(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__DMatrix__zeros__4(std::string ** err_msg, int x0, int x1);
-casadi::DMatrix*
-    casadi__DMatrix__zeros__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::DMatrix ret = casadi::DMatrix::zeros(x0_, x1_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getRepresentation"
-// cWrapperName: "casadi__DMatrix__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DMatrix__getRepresentation(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__DMatrix__getRepresentation(std::string ** err_msg, casadi::DMatrix* obj);
-std::string*
-    casadi__DMatrix__getRepresentation(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::DMatrix"
-// cppName: "casadi::DMatrix::getDescription"
-// cWrapperName: "casadi__DMatrix__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DMatrix__getDescription(std::string ** err_msg, casadi::DMatrix* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__DMatrix__getDescription(std::string ** err_msg, casadi::DMatrix* obj);
-std::string*
-    casadi__DMatrix__getDescription(std::string ** err_msg, casadi::DMatrix* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "DaeBuilder")===============
-// classType: UserType (Namespace ["casadi"]) (Name "DaeBuilder")
-extern "C"
-void delete_casadi__DaeBuilder(casadi::DaeBuilder* obj);
-void delete_casadi__DaeBuilder(casadi::DaeBuilder* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder"
-// cWrapperName: "casadi__DaeBuilder__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DaeBuilder")
-// cWrapperRetType: "casadi::DaeBuilder*"
-// proto: "casadi::DaeBuilder*\n    casadi__DaeBuilder__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::DaeBuilder()"
-// params: []
-extern "C"
-casadi::DaeBuilder*
-    casadi__DaeBuilder__CONSTRUCTOR(std::string ** err_msg);
-casadi::DaeBuilder*
-    casadi__DaeBuilder__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::DaeBuilder();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "addLinearCombination" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::addLinearCombination"
-// cWrapperName: "casadi__DaeBuilder__addLinearCombination"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__addLinearCombination(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1)"
-// call: "obj->addLinearCombination(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec StdString))]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__addLinearCombination(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1);
-casadi::MX*
-    casadi__DaeBuilder__addLinearCombination(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);
-
-        casadi::MX ret = obj->addLinearCombination(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "addVariable" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::addVariable"
-// cWrapperName: "casadi__DaeBuilder__addVariable__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__addVariable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1)"
-// call: "obj->addVariable(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__addVariable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1);
-casadi::MX*
-    casadi__DaeBuilder__addVariable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-
-        casadi::MX ret = obj->addVariable(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "addVariable" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::addVariable"
-// cWrapperName: "casadi__DaeBuilder__addVariable__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__addVariable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->addVariable(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__addVariable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__addVariable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->addVariable(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "addVariable" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::addVariable"
-// cWrapperName: "casadi__DaeBuilder__addVariable__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__addVariable__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->addVariable(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__addVariable__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__DaeBuilder__addVariable__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->addVariable(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "addVariable" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::addVariable"
-// cWrapperName: "casadi__DaeBuilder__addVariable__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__addVariable__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1)"
-// call: "obj->addVariable(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Variable")))]
-extern "C"
-void
-    casadi__DaeBuilder__addVariable__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1);
-void
-    casadi__DaeBuilder__addVariable__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Variable& x1_ = Marshaling<casadi::Variable&,casadi::Variable*>::marshal(x1);
-
-        obj->addVariable(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_alg" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_alg"
-// cWrapperName: "casadi__DaeBuilder__add_alg__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_alg__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->add_alg(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__DaeBuilder__add_alg__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-void
-    casadi__DaeBuilder__add_alg__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->add_alg(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_alg" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_alg"
-// cWrapperName: "casadi__DaeBuilder__add_alg__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_alg__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// call: "obj->add_alg(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__DaeBuilder__add_alg__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
-void
-    casadi__DaeBuilder__add_alg__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->add_alg(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_d" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_d"
-// cWrapperName: "casadi__DaeBuilder__add_d__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_d__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->add_d(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_d__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-casadi::MX*
-    casadi__DaeBuilder__add_d__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        casadi::MX ret = obj->add_d(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_d" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_d"
-// cWrapperName: "casadi__DaeBuilder__add_d__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_d__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// call: "obj->add_d(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_d__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
-casadi::MX*
-    casadi__DaeBuilder__add_d__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->add_d(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_dae" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_dae"
-// cWrapperName: "casadi__DaeBuilder__add_dae__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_dae__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->add_dae(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__DaeBuilder__add_dae__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-void
-    casadi__DaeBuilder__add_dae__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->add_dae(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_dae" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_dae"
-// cWrapperName: "casadi__DaeBuilder__add_dae__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_dae__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// call: "obj->add_dae(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__DaeBuilder__add_dae__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
-void
-    casadi__DaeBuilder__add_dae__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->add_dae(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_ode" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_ode"
-// cWrapperName: "casadi__DaeBuilder__add_ode__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_ode__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->add_ode(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__DaeBuilder__add_ode__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-void
-    casadi__DaeBuilder__add_ode__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->add_ode(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_ode" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_ode"
-// cWrapperName: "casadi__DaeBuilder__add_ode__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_ode__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// call: "obj->add_ode(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__DaeBuilder__add_ode__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
-void
-    casadi__DaeBuilder__add_ode__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->add_ode(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_p" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_p"
-// cWrapperName: "casadi__DaeBuilder__add_p__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_p__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->add_p()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_p__0(std::string ** err_msg, casadi::DaeBuilder* obj);
-casadi::MX*
-    casadi__DaeBuilder__add_p__0(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        casadi::MX ret = obj->add_p();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_p" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_p"
-// cWrapperName: "casadi__DaeBuilder__add_p__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_p__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->add_p(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_p__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__add_p__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->add_p(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_p" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_p"
-// cWrapperName: "casadi__DaeBuilder__add_p__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_p__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->add_p(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_p__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__DaeBuilder__add_p__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->add_p(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_q" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_q"
-// cWrapperName: "casadi__DaeBuilder__add_q__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_q__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->add_q()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_q__0(std::string ** err_msg, casadi::DaeBuilder* obj);
-casadi::MX*
-    casadi__DaeBuilder__add_q__0(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        casadi::MX ret = obj->add_q();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_q" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_q"
-// cWrapperName: "casadi__DaeBuilder__add_q__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_q__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->add_q(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_q__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__add_q__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->add_q(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_q" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_q"
-// cWrapperName: "casadi__DaeBuilder__add_q__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_q__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->add_q(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_q__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__DaeBuilder__add_q__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->add_q(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_quad" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_quad"
-// cWrapperName: "casadi__DaeBuilder__add_quad__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_quad__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->add_quad(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__DaeBuilder__add_quad__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-void
-    casadi__DaeBuilder__add_quad__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->add_quad(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_quad" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_quad"
-// cWrapperName: "casadi__DaeBuilder__add_quad__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__add_quad__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// call: "obj->add_quad(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__DaeBuilder__add_quad__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
-void
-    casadi__DaeBuilder__add_quad__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->add_quad(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "add_s" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_s"
-// cWrapperName: "casadi__DaeBuilder__add_s__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: StdPair (UserType (Namespace ["casadi"]) (Name "MX")) (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::pair< casadi::MX*, casadi::MX* >*"
-// proto: "std::pair< casadi::MX*, casadi::MX* >*\n    casadi__DaeBuilder__add_s__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->add_s()"
-// params: []
-extern "C"
-std::pair< casadi::MX*, casadi::MX* >*
-    casadi__DaeBuilder__add_s__0(std::string ** err_msg, casadi::DaeBuilder* obj);
-std::pair< casadi::MX*, casadi::MX* >*
-    casadi__DaeBuilder__add_s__0(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        std::pair< casadi::MX, casadi::MX > ret = obj->add_s();
-        return WrapReturn< std::pair< casadi::MX*, casadi::MX* >*, std::pair< casadi::MX, casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_s" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_s"
-// cWrapperName: "casadi__DaeBuilder__add_s__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdPair (UserType (Namespace ["casadi"]) (Name "MX")) (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::pair< casadi::MX*, casadi::MX* >*"
-// proto: "std::pair< casadi::MX*, casadi::MX* >*\n    casadi__DaeBuilder__add_s__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->add_s(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::pair< casadi::MX*, casadi::MX* >*
-    casadi__DaeBuilder__add_s__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-std::pair< casadi::MX*, casadi::MX* >*
-    casadi__DaeBuilder__add_s__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::pair< casadi::MX, casadi::MX > ret = obj->add_s(x0_);
-        return WrapReturn< std::pair< casadi::MX*, casadi::MX* >*, std::pair< casadi::MX, casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_s" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_s"
-// cWrapperName: "casadi__DaeBuilder__add_s__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdPair (UserType (Namespace ["casadi"]) (Name "MX")) (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::pair< casadi::MX*, casadi::MX* >*"
-// proto: "std::pair< casadi::MX*, casadi::MX* >*\n    casadi__DaeBuilder__add_s__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->add_s(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-std::pair< casadi::MX*, casadi::MX* >*
-    casadi__DaeBuilder__add_s__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-std::pair< casadi::MX*, casadi::MX* >*
-    casadi__DaeBuilder__add_s__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        std::pair< casadi::MX, casadi::MX > ret = obj->add_s(x0_, x1_);
-        return WrapReturn< std::pair< casadi::MX*, casadi::MX* >*, std::pair< casadi::MX, casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_u" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_u"
-// cWrapperName: "casadi__DaeBuilder__add_u__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_u__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->add_u()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_u__0(std::string ** err_msg, casadi::DaeBuilder* obj);
-casadi::MX*
-    casadi__DaeBuilder__add_u__0(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        casadi::MX ret = obj->add_u();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_u" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_u"
-// cWrapperName: "casadi__DaeBuilder__add_u__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_u__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->add_u(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_u__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__add_u__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->add_u(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_u" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_u"
-// cWrapperName: "casadi__DaeBuilder__add_u__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_u__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->add_u(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_u__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__DaeBuilder__add_u__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->add_u(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_x" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_x"
-// cWrapperName: "casadi__DaeBuilder__add_x__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_x__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->add_x()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_x__0(std::string ** err_msg, casadi::DaeBuilder* obj);
-casadi::MX*
-    casadi__DaeBuilder__add_x__0(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        casadi::MX ret = obj->add_x();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_x" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_x"
-// cWrapperName: "casadi__DaeBuilder__add_x__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_x__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->add_x(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_x__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__add_x__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->add_x(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_x" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_x"
-// cWrapperName: "casadi__DaeBuilder__add_x__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_x__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->add_x(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_x__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__DaeBuilder__add_x__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->add_x(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_y" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_y"
-// cWrapperName: "casadi__DaeBuilder__add_y__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_y__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->add_y(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_y__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-casadi::MX*
-    casadi__DaeBuilder__add_y__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        casadi::MX ret = obj->add_y(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_y" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_y"
-// cWrapperName: "casadi__DaeBuilder__add_y__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_y__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
-// call: "obj->add_y(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_y__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
-casadi::MX*
-    casadi__DaeBuilder__add_y__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->add_y(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_z" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_z"
-// cWrapperName: "casadi__DaeBuilder__add_z__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_z__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->add_z()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_z__0(std::string ** err_msg, casadi::DaeBuilder* obj);
-casadi::MX*
-    casadi__DaeBuilder__add_z__0(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        casadi::MX ret = obj->add_z();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_z" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_z"
-// cWrapperName: "casadi__DaeBuilder__add_z__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_z__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->add_z(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_z__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__add_z__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->add_z(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "add_z" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::add_z"
-// cWrapperName: "casadi__DaeBuilder__add_z__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__add_z__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->add_z(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__add_z__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__DaeBuilder__add_z__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->add_z(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "create" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::create"
-// cWrapperName: "casadi__DaeBuilder__create"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__DaeBuilder__create(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2)"
-// call: "obj->create(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec StdString)),Ref (Const (StdVec StdString))]
-extern "C"
-casadi::MXFunction*
-    casadi__DaeBuilder__create(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2);
-casadi::MXFunction*
-    casadi__DaeBuilder__create(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);
-        std::vector< std::string > x2_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x2);
-
-        casadi::MXFunction ret = obj->create(x0_, x1_, x2_);
-        return WrapReturn< casadi::MXFunction*, casadi::MXFunction >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "der" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::der"
-// cWrapperName: "casadi__DaeBuilder__der__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__der__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->der(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__der__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-casadi::MX*
-    casadi__DaeBuilder__der__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        casadi::MX ret = obj->der(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "der" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::der"
-// cWrapperName: "casadi__DaeBuilder__der__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__der__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->der(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__der__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__der__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->der(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "derivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::derivativeStart"
-// cWrapperName: "casadi__DaeBuilder__derivativeStart__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__derivativeStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->derivativeStart(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__derivativeStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-std::vector< double >*
-    casadi__DaeBuilder__derivativeStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::vector< double > ret = obj->derivativeStart(x0_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "derivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::derivativeStart"
-// cWrapperName: "casadi__DaeBuilder__derivativeStart__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__derivativeStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// call: "obj->derivativeStart(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__derivativeStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
-std::vector< double >*
-    casadi__DaeBuilder__derivativeStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< double > ret = obj->derivativeStart(x0_, x1_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "derivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::derivativeStart"
-// cWrapperName: "casadi__DaeBuilder__derivativeStart__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__derivativeStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->derivativeStart(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-double
-    casadi__DaeBuilder__derivativeStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-double
-    casadi__DaeBuilder__derivativeStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        double ret = obj->derivativeStart(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "derivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::derivativeStart"
-// cWrapperName: "casadi__DaeBuilder__derivativeStart__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__derivativeStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->derivativeStart(x0_, x1_)"
-// params: [Ref (Const StdString),CBool]
-extern "C"
-double
-    casadi__DaeBuilder__derivativeStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-double
-    casadi__DaeBuilder__derivativeStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        double ret = obj->derivativeStart(x0_, x1_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "eliminate_alg" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::eliminate_alg"
-// cWrapperName: "casadi__DaeBuilder__eliminate_alg"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__eliminate_alg(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->eliminate_alg()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__eliminate_alg(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__eliminate_alg(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->eliminate_alg();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "eliminate_d" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::eliminate_d"
-// cWrapperName: "casadi__DaeBuilder__eliminate_d"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__eliminate_d(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->eliminate_d()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__eliminate_d(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__eliminate_d(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->eliminate_d();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "eliminate_quad" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::eliminate_quad"
-// cWrapperName: "casadi__DaeBuilder__eliminate_quad"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__eliminate_quad(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->eliminate_quad()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__eliminate_quad(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__eliminate_quad(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->eliminate_quad();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "initialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::initialGuess"
-// cWrapperName: "casadi__DaeBuilder__initialGuess__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__initialGuess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->initialGuess(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__initialGuess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-std::vector< double >*
-    casadi__DaeBuilder__initialGuess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::vector< double > ret = obj->initialGuess(x0_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "initialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::initialGuess"
-// cWrapperName: "casadi__DaeBuilder__initialGuess__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__initialGuess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// call: "obj->initialGuess(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__initialGuess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
-std::vector< double >*
-    casadi__DaeBuilder__initialGuess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< double > ret = obj->initialGuess(x0_, x1_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "initialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::initialGuess"
-// cWrapperName: "casadi__DaeBuilder__initialGuess__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__initialGuess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->initialGuess(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-double
-    casadi__DaeBuilder__initialGuess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-double
-    casadi__DaeBuilder__initialGuess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        double ret = obj->initialGuess(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "initialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::initialGuess"
-// cWrapperName: "casadi__DaeBuilder__initialGuess__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__initialGuess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->initialGuess(x0_, x1_)"
-// params: [Ref (Const StdString),CBool]
-extern "C"
-double
-    casadi__DaeBuilder__initialGuess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-double
-    casadi__DaeBuilder__initialGuess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        double ret = obj->initialGuess(x0_, x1_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "makeExplicit" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::makeExplicit"
-// cWrapperName: "casadi__DaeBuilder__makeExplicit"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__makeExplicit(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->makeExplicit()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__makeExplicit(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__makeExplicit(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->makeExplicit();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "makeSemiExplicit" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::makeSemiExplicit"
-// cWrapperName: "casadi__DaeBuilder__makeSemiExplicit"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__makeSemiExplicit(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->makeSemiExplicit()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__makeSemiExplicit(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__makeSemiExplicit(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->makeSemiExplicit();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "max" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::max"
-// cWrapperName: "casadi__DaeBuilder__max__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->max(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-std::vector< double >*
-    casadi__DaeBuilder__max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::vector< double > ret = obj->max(x0_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "max" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::max"
-// cWrapperName: "casadi__DaeBuilder__max__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// call: "obj->max(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
-std::vector< double >*
-    casadi__DaeBuilder__max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< double > ret = obj->max(x0_, x1_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "max" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::max"
-// cWrapperName: "casadi__DaeBuilder__max__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->max(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-double
-    casadi__DaeBuilder__max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-double
-    casadi__DaeBuilder__max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        double ret = obj->max(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "max" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::max"
-// cWrapperName: "casadi__DaeBuilder__max__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->max(x0_, x1_)"
-// params: [Ref (Const StdString),CBool]
-extern "C"
-double
-    casadi__DaeBuilder__max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-double
-    casadi__DaeBuilder__max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        double ret = obj->max(x0_, x1_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "min" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::min"
-// cWrapperName: "casadi__DaeBuilder__min__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->min(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-std::vector< double >*
-    casadi__DaeBuilder__min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::vector< double > ret = obj->min(x0_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "min" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::min"
-// cWrapperName: "casadi__DaeBuilder__min__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// call: "obj->min(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
-std::vector< double >*
-    casadi__DaeBuilder__min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< double > ret = obj->min(x0_, x1_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "min" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::min"
-// cWrapperName: "casadi__DaeBuilder__min__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->min(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-double
-    casadi__DaeBuilder__min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-double
-    casadi__DaeBuilder__min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        double ret = obj->min(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "min" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::min"
-// cWrapperName: "casadi__DaeBuilder__min__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->min(x0_, x1_)"
-// params: [Ref (Const StdString),CBool]
-extern "C"
-double
-    casadi__DaeBuilder__min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-double
-    casadi__DaeBuilder__min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        double ret = obj->min(x0_, x1_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nominal" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::nominal"
-// cWrapperName: "casadi__DaeBuilder__nominal__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->nominal(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-std::vector< double >*
-    casadi__DaeBuilder__nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::vector< double > ret = obj->nominal(x0_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nominal" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::nominal"
-// cWrapperName: "casadi__DaeBuilder__nominal__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->nominal(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-double
-    casadi__DaeBuilder__nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-double
-    casadi__DaeBuilder__nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        double ret = obj->nominal(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::operator ()"
-// cWrapperName: "casadi__DaeBuilder__operator_call"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__DaeBuilder__operator_call(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__DaeBuilder__operator_call(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::MX*
-    casadi__DaeBuilder__operator_call(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->operator ()(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "parseFMI" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::parseFMI"
-// cWrapperName: "casadi__DaeBuilder__parseFMI"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__parseFMI(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->parseFMI(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__DaeBuilder__parseFMI(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-void
-    casadi__DaeBuilder__parseFMI(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->parseFMI(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::sanityCheck"
-// cWrapperName: "casadi__DaeBuilder__sanityCheck"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__sanityCheck(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->sanityCheck()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__sanityCheck(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__sanityCheck(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->sanityCheck();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "scaleEquations" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::scaleEquations"
-// cWrapperName: "casadi__DaeBuilder__scaleEquations"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__scaleEquations(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->scaleEquations()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__scaleEquations(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__scaleEquations(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->scaleEquations();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "scaleVariables" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::scaleVariables"
-// cWrapperName: "casadi__DaeBuilder__scaleVariables"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__scaleVariables(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->scaleVariables()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__scaleVariables(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__scaleVariables(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->scaleVariables();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setDerivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setDerivativeStart"
-// cWrapperName: "casadi__DaeBuilder__setDerivativeStart__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setDerivativeStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// call: "obj->setDerivativeStart(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DaeBuilder__setDerivativeStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
-void
-    casadi__DaeBuilder__setDerivativeStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-
-        obj->setDerivativeStart(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setDerivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setDerivativeStart"
-// cWrapperName: "casadi__DaeBuilder__setDerivativeStart__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setDerivativeStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// call: "obj->setDerivativeStart(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setDerivativeStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
-void
-    casadi__DaeBuilder__setDerivativeStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setDerivativeStart(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setDerivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setDerivativeStart"
-// cWrapperName: "casadi__DaeBuilder__setDerivativeStart__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setDerivativeStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// call: "obj->setDerivativeStart(x0_, x1_)"
-// params: [Ref (Const StdString),CDouble]
-extern "C"
-void
-    casadi__DaeBuilder__setDerivativeStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
-void
-    casadi__DaeBuilder__setDerivativeStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-
-        obj->setDerivativeStart(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setDerivativeStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setDerivativeStart"
-// cWrapperName: "casadi__DaeBuilder__setDerivativeStart__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setDerivativeStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// call: "obj->setDerivativeStart(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CDouble,CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setDerivativeStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
-void
-    casadi__DaeBuilder__setDerivativeStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setDerivativeStart(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInitialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setInitialGuess"
-// cWrapperName: "casadi__DaeBuilder__setInitialGuess__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setInitialGuess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// call: "obj->setInitialGuess(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DaeBuilder__setInitialGuess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
-void
-    casadi__DaeBuilder__setInitialGuess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-
-        obj->setInitialGuess(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInitialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setInitialGuess"
-// cWrapperName: "casadi__DaeBuilder__setInitialGuess__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setInitialGuess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// call: "obj->setInitialGuess(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setInitialGuess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
-void
-    casadi__DaeBuilder__setInitialGuess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setInitialGuess(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInitialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setInitialGuess"
-// cWrapperName: "casadi__DaeBuilder__setInitialGuess__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setInitialGuess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// call: "obj->setInitialGuess(x0_, x1_)"
-// params: [Ref (Const StdString),CDouble]
-extern "C"
-void
-    casadi__DaeBuilder__setInitialGuess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
-void
-    casadi__DaeBuilder__setInitialGuess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-
-        obj->setInitialGuess(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInitialGuess" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setInitialGuess"
-// cWrapperName: "casadi__DaeBuilder__setInitialGuess__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setInitialGuess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// call: "obj->setInitialGuess(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CDouble,CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setInitialGuess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
-void
-    casadi__DaeBuilder__setInitialGuess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setInitialGuess(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMax" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMax"
-// cWrapperName: "casadi__DaeBuilder__setMax__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMax__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// call: "obj->setMax(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DaeBuilder__setMax__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
-void
-    casadi__DaeBuilder__setMax__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-
-        obj->setMax(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMax" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMax"
-// cWrapperName: "casadi__DaeBuilder__setMax__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMax__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// call: "obj->setMax(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setMax__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
-void
-    casadi__DaeBuilder__setMax__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setMax(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMax" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMax"
-// cWrapperName: "casadi__DaeBuilder__setMax__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMax__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// call: "obj->setMax(x0_, x1_)"
-// params: [Ref (Const StdString),CDouble]
-extern "C"
-void
-    casadi__DaeBuilder__setMax__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
-void
-    casadi__DaeBuilder__setMax__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-
-        obj->setMax(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMax" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMax"
-// cWrapperName: "casadi__DaeBuilder__setMax__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMax__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// call: "obj->setMax(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CDouble,CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setMax__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
-void
-    casadi__DaeBuilder__setMax__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setMax(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMin" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMin"
-// cWrapperName: "casadi__DaeBuilder__setMin__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMin__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// call: "obj->setMin(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DaeBuilder__setMin__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
-void
-    casadi__DaeBuilder__setMin__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-
-        obj->setMin(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMin" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMin"
-// cWrapperName: "casadi__DaeBuilder__setMin__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMin__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// call: "obj->setMin(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setMin__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
-void
-    casadi__DaeBuilder__setMin__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setMin(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMin" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMin"
-// cWrapperName: "casadi__DaeBuilder__setMin__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMin__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// call: "obj->setMin(x0_, x1_)"
-// params: [Ref (Const StdString),CDouble]
-extern "C"
-void
-    casadi__DaeBuilder__setMin__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
-void
-    casadi__DaeBuilder__setMin__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-
-        obj->setMin(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setMin" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setMin"
-// cWrapperName: "casadi__DaeBuilder__setMin__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setMin__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// call: "obj->setMin(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CDouble,CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setMin__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
-void
-    casadi__DaeBuilder__setMin__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setMin(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNominal" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setNominal"
-// cWrapperName: "casadi__DaeBuilder__setNominal__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setNominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// call: "obj->setNominal(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DaeBuilder__setNominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
-void
-    casadi__DaeBuilder__setNominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-
-        obj->setNominal(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNominal" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setNominal"
-// cWrapperName: "casadi__DaeBuilder__setNominal__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setNominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// call: "obj->setNominal(x0_, x1_)"
-// params: [Ref (Const StdString),CDouble]
-extern "C"
-void
-    casadi__DaeBuilder__setNominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
-void
-    casadi__DaeBuilder__setNominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-
-        obj->setNominal(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setStart"
-// cWrapperName: "casadi__DaeBuilder__setStart__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
-// call: "obj->setStart(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__DaeBuilder__setStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
-void
-    casadi__DaeBuilder__setStart__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-
-        obj->setStart(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setStart"
-// cWrapperName: "casadi__DaeBuilder__setStart__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
-// call: "obj->setStart(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
-void
-    casadi__DaeBuilder__setStart__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setStart(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setStart"
-// cWrapperName: "casadi__DaeBuilder__setStart__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
-// call: "obj->setStart(x0_, x1_)"
-// params: [Ref (Const StdString),CDouble]
-extern "C"
-void
-    casadi__DaeBuilder__setStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
-void
-    casadi__DaeBuilder__setStart__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-
-        obj->setStart(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setStart" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setStart"
-// cWrapperName: "casadi__DaeBuilder__setStart__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
-// call: "obj->setStart(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CDouble,CBool]
-extern "C"
-void
-    casadi__DaeBuilder__setStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
-void
-    casadi__DaeBuilder__setStart__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        double x1_ = Marshaling<double,double>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->setStart(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setUnit" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::setUnit"
-// cWrapperName: "casadi__DaeBuilder__setUnit"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__setUnit(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1)"
-// call: "obj->setUnit(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-void
-    casadi__DaeBuilder__setUnit(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1);
-void
-    casadi__DaeBuilder__setUnit(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->setUnit(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sort_alg" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::sort_alg"
-// cWrapperName: "casadi__DaeBuilder__sort_alg"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__sort_alg(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->sort_alg()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__sort_alg(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__sort_alg(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->sort_alg();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sort_d" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::sort_d"
-// cWrapperName: "casadi__DaeBuilder__sort_d"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__sort_d(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->sort_d()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__sort_d(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__sort_d(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->sort_d();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sort_dae" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::sort_dae"
-// cWrapperName: "casadi__DaeBuilder__sort_dae"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__sort_dae(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->sort_dae()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__sort_dae(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__sort_dae(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->sort_dae();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "split_d" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::split_d"
-// cWrapperName: "casadi__DaeBuilder__split_d"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__split_d(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->split_d()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__split_d(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__split_d(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->split_d();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "split_dae" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::split_dae"
-// cWrapperName: "casadi__DaeBuilder__split_dae"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DaeBuilder__split_dae(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->split_dae()"
-// params: []
-extern "C"
-void
-    casadi__DaeBuilder__split_dae(std::string ** err_msg, casadi::DaeBuilder* obj);
-void
-    casadi__DaeBuilder__split_dae(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        obj->split_dae();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "start" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::start"
-// cWrapperName: "casadi__DaeBuilder__start__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->start(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-std::vector< double >*
-    casadi__DaeBuilder__start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::vector< double > ret = obj->start(x0_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "start" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::start"
-// cWrapperName: "casadi__DaeBuilder__start__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__DaeBuilder__start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
-// call: "obj->start(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
-extern "C"
-std::vector< double >*
-    casadi__DaeBuilder__start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
-std::vector< double >*
-    casadi__DaeBuilder__start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< double > ret = obj->start(x0_, x1_);
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "start" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::start"
-// cWrapperName: "casadi__DaeBuilder__start__2"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->start(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-double
-    casadi__DaeBuilder__start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-double
-    casadi__DaeBuilder__start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        double ret = obj->start(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "start" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::start"
-// cWrapperName: "casadi__DaeBuilder__start__3"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__DaeBuilder__start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
-// call: "obj->start(x0_, x1_)"
-// params: [Ref (Const StdString),CBool]
-extern "C"
-double
-    casadi__DaeBuilder__start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
-double
-    casadi__DaeBuilder__start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        double ret = obj->start(x0_, x1_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "unit" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::unit"
-// cWrapperName: "casadi__DaeBuilder__unit__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DaeBuilder__unit__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
-// call: "obj->unit(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::string*
-    casadi__DaeBuilder__unit__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
-std::string*
-    casadi__DaeBuilder__unit__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::string ret = obj->unit(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "unit" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::unit"
-// cWrapperName: "casadi__DaeBuilder__unit__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DaeBuilder__unit__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->unit(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__DaeBuilder__unit__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-std::string*
-    casadi__DaeBuilder__unit__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = obj->unit(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "variable" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::variable"
-// cWrapperName: "casadi__DaeBuilder__variable__0"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Variable"))
-// cWrapperRetType: "casadi::Variable*"
-// proto: "casadi::Variable*\n    casadi__DaeBuilder__variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->variable(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Variable*
-    casadi__DaeBuilder__variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::Variable*
-    casadi__DaeBuilder__variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Variable ret = obj->variable(x0_);
-        return WrapReturn< casadi::Variable*, casadi::Variable >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "variable" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::variable"
-// cWrapperName: "casadi__DaeBuilder__variable__1"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
-// cWrapperRetType: "casadi::Variable*"
-// proto: "casadi::Variable*\n    casadi__DaeBuilder__variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
-// call: "obj->variable(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Variable*
-    casadi__DaeBuilder__variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
-casadi::Variable*
-    casadi__DaeBuilder__variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Variable ret = obj->variable(x0_);
-        return WrapReturn< casadi::Variable*, casadi::Variable >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::getRepresentation"
-// cWrapperName: "casadi__DaeBuilder__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DaeBuilder__getRepresentation(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__DaeBuilder__getRepresentation(std::string ** err_msg, casadi::DaeBuilder* obj);
-std::string*
-    casadi__DaeBuilder__getRepresentation(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::DaeBuilder"
-// cppName: "casadi::DaeBuilder::getDescription"
-// cWrapperName: "casadi__DaeBuilder__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DaeBuilder__getDescription(std::string ** err_msg, casadi::DaeBuilder* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__DaeBuilder__getDescription(std::string ** err_msg, casadi::DaeBuilder* obj);
-std::string*
-    casadi__DaeBuilder__getDescription(std::string ** err_msg, casadi::DaeBuilder* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")===============
-// classType: UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")
-extern "C"
-void delete_casadi__DerivativeGenerator(casadi::DerivativeGenerator* obj);
-void delete_casadi__DerivativeGenerator(casadi::DerivativeGenerator* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DerivativeGenerator"
-// cppName: "casadi::DerivativeGenerator"
-// cWrapperName: "casadi__DerivativeGenerator__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")
-// cWrapperRetType: "casadi::DerivativeGenerator*"
-// proto: "casadi::DerivativeGenerator*\n    casadi__DerivativeGenerator__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::DerivativeGenerator()"
-// params: []
-extern "C"
-casadi::DerivativeGenerator*
-    casadi__DerivativeGenerator__CONSTRUCTOR(std::string ** err_msg);
-casadi::DerivativeGenerator*
-    casadi__DerivativeGenerator__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::DerivativeGenerator();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "DerivativeGenerator2")===============
-// classType: UserType (Namespace ["casadi"]) (Name "DerivativeGenerator2")
-extern "C"
-void delete_casadi__DerivativeGenerator2(casadi::DerivativeGenerator2* obj);
-void delete_casadi__DerivativeGenerator2(casadi::DerivativeGenerator2* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DerivativeGenerator2"
-// cppName: "casadi::DerivativeGenerator2"
-// cWrapperName: "casadi__DerivativeGenerator2__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DerivativeGenerator2")
-// cWrapperRetType: "casadi::DerivativeGenerator2*"
-// proto: "casadi::DerivativeGenerator2*\n    casadi__DerivativeGenerator2__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::DerivativeGenerator2()"
-// params: []
-extern "C"
-casadi::DerivativeGenerator2*
-    casadi__DerivativeGenerator2__CONSTRUCTOR(std::string ** err_msg);
-casadi::DerivativeGenerator2*
-    casadi__DerivativeGenerator2__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::DerivativeGenerator2();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "create" ===============
-// class: "casadi::DerivativeGenerator2"
-// cppName: "casadi::DerivativeGenerator2::create"
-// cWrapperName: "casadi__DerivativeGenerator2__create"
-// protoArgs: "(std::string ** err_msg, casadi::DerivativeGenerator2* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")
-// cWrapperRetType: "casadi::DerivativeGenerator*"
-// proto: "casadi::DerivativeGenerator*\n    casadi__DerivativeGenerator2__create(std::string ** err_msg, casadi::DerivativeGenerator2* obj)"
-// call: "obj->create()"
-// params: []
-extern "C"
-casadi::DerivativeGenerator*
-    casadi__DerivativeGenerator2__create(std::string ** err_msg, casadi::DerivativeGenerator2* obj);
-casadi::DerivativeGenerator*
-    casadi__DerivativeGenerator2__create(std::string ** err_msg, casadi::DerivativeGenerator2* obj){
-    try {
-
-        casadi::DerivativeGenerator ret = obj->create();
-        return WrapReturn< casadi::DerivativeGenerator*, casadi::DerivativeGenerator >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::DerivativeGenerator2"
-// cppName: "casadi::DerivativeGenerator2::operator ()"
-// cWrapperName: "casadi__DerivativeGenerator2__operator_call"
-// protoArgs: "(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__DerivativeGenerator2__operator_call(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1)"
-// call: "obj->operator ()(x0_, x1_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function")),CInt]
-extern "C"
-casadi::Function*
-    casadi__DerivativeGenerator2__operator_call(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1);
-casadi::Function*
-    casadi__DerivativeGenerator2__operator_call(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->operator ()(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "original" ===============
-// class: "casadi::DerivativeGenerator2"
-// cppName: "casadi::DerivativeGenerator2::original"
-// cWrapperName: "casadi__DerivativeGenerator2__original"
-// protoArgs: "(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__DerivativeGenerator2__original(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1, int x2)"
-// call: "obj->original(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function")),CInt,CBool]
-extern "C"
-casadi::Function*
-    casadi__DerivativeGenerator2__original(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1, int x2);
-casadi::Function*
-    casadi__DerivativeGenerator2__original(std::string ** err_msg, casadi::DerivativeGenerator2* obj, casadi::Function* x0, int x1, int x2){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Function ret = obj->original(x0_, x1_, x2_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "DleSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "DleSolver")
-extern "C"
-void delete_casadi__DleSolver(casadi::DleSolver* obj);
-void delete_casadi__DleSolver(casadi::DleSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver"
-// cWrapperName: "casadi__DleSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DleSolver")
-// cWrapperRetType: "casadi::DleSolver*"
-// proto: "casadi::DleSolver*\n    casadi__DleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::DleSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::DleSolver*
-    casadi__DleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::DleSolver*
-    casadi__DleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::DleSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver"
-// cWrapperName: "casadi__DleSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DleSolver")
-// cWrapperRetType: "casadi::DleSolver*"
-// proto: "casadi::DleSolver*\n    casadi__DleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::DleSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::DleSolver*
-    casadi__DleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::DleSolver*
-    casadi__DleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::DleSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver"
-// cWrapperName: "casadi__DleSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DleSolver")
-// cWrapperRetType: "casadi::DleSolver*"
-// proto: "casadi::DleSolver*\n    casadi__DleSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::DleSolver()"
-// params: []
-extern "C"
-casadi::DleSolver*
-    casadi__DleSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::DleSolver*
-    casadi__DleSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::DleSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clone" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver::clone"
-// cWrapperName: "casadi__DleSolver__clone"
-// protoArgs: "(std::string ** err_msg, casadi::DleSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DleSolver")
-// cWrapperRetType: "casadi::DleSolver*"
-// proto: "casadi::DleSolver*\n    casadi__DleSolver__clone(std::string ** err_msg, casadi::DleSolver* obj)"
-// call: "obj->clone()"
-// params: []
-extern "C"
-casadi::DleSolver*
-    casadi__DleSolver__clone(std::string ** err_msg, casadi::DleSolver* obj);
-casadi::DleSolver*
-    casadi__DleSolver__clone(std::string ** err_msg, casadi::DleSolver* obj){
-    try {
-
-        casadi::DleSolver ret = obj->clone();
-        return WrapReturn< casadi::DleSolver*, casadi::DleSolver >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver::doc"
-// cWrapperName: "casadi__DleSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DleSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::DleSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__DleSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__DleSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::DleSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getSparsity" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver::getSparsity"
-// cWrapperName: "casadi__DleSolver__getSparsity"
-// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__DleSolver__getSparsity(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0)"
-// call: "casadi::DleSolver::getSparsity(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::Sparsity*
-    casadi__DleSolver__getSparsity(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0);
-casadi::Sparsity*
-    casadi__DleSolver__getSparsity(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0){
-    try {
-        std::map< std::string, casadi::Sparsity > x0_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::DleSolver::getSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver::hasPlugin"
-// cWrapperName: "casadi__DleSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DleSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::DleSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__DleSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__DleSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::DleSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver::loadPlugin"
-// cWrapperName: "casadi__DleSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DleSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::DleSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__DleSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__DleSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::DleSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printStats" ===============
-// class: "casadi::DleSolver"
-// cppName: "casadi::DleSolver::printStats"
-// cWrapperName: "casadi__DleSolver__printStats"
-// protoArgs: "(std::string ** err_msg, casadi::DleSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DleSolver__printStats(std::string ** err_msg, casadi::DleSolver* obj)"
-// call: "obj->printStats()"
-// params: []
-extern "C"
-void
-    casadi__DleSolver__printStats(std::string ** err_msg, casadi::DleSolver* obj);
-void
-    casadi__DleSolver__printStats(std::string ** err_msg, casadi::DleSolver* obj){
-    try {
-
-        obj->printStats();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "DpleSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "DpleSolver")
-extern "C"
-void delete_casadi__DpleSolver(casadi::DpleSolver* obj);
-void delete_casadi__DpleSolver(casadi::DpleSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver"
-// cWrapperName: "casadi__DpleSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DpleSolver")
-// cWrapperRetType: "casadi::DpleSolver*"
-// proto: "casadi::DpleSolver*\n    casadi__DpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2)"
-// call: "casadi::DpleSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))))]
-extern "C"
-casadi::DpleSolver*
-    casadi__DpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2);
-casadi::DpleSolver*
-    casadi__DpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, std::vector< casadi::Sparsity > > x2_ = Marshaling<std::map< std::string, std::vector< casadi::Sparsity > >,std::map< std::string, std::vector< casadi::Sparsity* >* >*>::marshal(x2);
-
-        return new casadi::DpleSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver"
-// cWrapperName: "casadi__DpleSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DpleSolver")
-// cWrapperRetType: "casadi::DpleSolver*"
-// proto: "casadi::DpleSolver*\n    casadi__DpleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::DpleSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::DpleSolver*
-    casadi__DpleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::DpleSolver*
-    casadi__DpleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, std::vector< casadi::Sparsity > > x2_ = Marshaling<std::map< std::string, std::vector< casadi::Sparsity > >,std::map< std::string, std::vector< casadi::Sparsity* >* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::DpleSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver"
-// cWrapperName: "casadi__DpleSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DpleSolver")
-// cWrapperRetType: "casadi::DpleSolver*"
-// proto: "casadi::DpleSolver*\n    casadi__DpleSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::DpleSolver()"
-// params: []
-extern "C"
-casadi::DpleSolver*
-    casadi__DpleSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::DpleSolver*
-    casadi__DpleSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::DpleSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clone" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver::clone"
-// cWrapperName: "casadi__DpleSolver__clone"
-// protoArgs: "(std::string ** err_msg, casadi::DpleSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DpleSolver")
-// cWrapperRetType: "casadi::DpleSolver*"
-// proto: "casadi::DpleSolver*\n    casadi__DpleSolver__clone(std::string ** err_msg, casadi::DpleSolver* obj)"
-// call: "obj->clone()"
-// params: []
-extern "C"
-casadi::DpleSolver*
-    casadi__DpleSolver__clone(std::string ** err_msg, casadi::DpleSolver* obj);
-casadi::DpleSolver*
-    casadi__DpleSolver__clone(std::string ** err_msg, casadi::DpleSolver* obj){
-    try {
-
-        casadi::DpleSolver ret = obj->clone();
-        return WrapReturn< casadi::DpleSolver*, casadi::DpleSolver >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver::doc"
-// cWrapperName: "casadi__DpleSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__DpleSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::DpleSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__DpleSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__DpleSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::DpleSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver::hasPlugin"
-// cWrapperName: "casadi__DpleSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__DpleSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::DpleSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__DpleSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__DpleSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::DpleSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver::loadPlugin"
-// cWrapperName: "casadi__DpleSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DpleSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::DpleSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__DpleSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__DpleSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::DpleSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "periodic_schur" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver::periodic_schur"
-// cWrapperName: "casadi__DpleSolver__periodic_schur__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DpleSolver__periodic_schur__0(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5)"
-// call: "casadi::DpleSolver::periodic_schur(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (StdVec CDouble),Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__DpleSolver__periodic_schur__0(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5);
-void
-    casadi__DpleSolver__periodic_schur__0(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< casadi::DMatrix > x2_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x2);
-        std::vector< casadi::DMatrix > x3_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x3);
-        std::vector< double > x4_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x4);
-        std::vector< double > x5_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x5);
-
-        casadi::DpleSolver::periodic_schur(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "periodic_schur" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver::periodic_schur"
-// cWrapperName: "casadi__DpleSolver__periodic_schur__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5, double x6)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DpleSolver__periodic_schur__1(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5, double x6)"
-// call: "casadi::DpleSolver::periodic_schur(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (StdVec CDouble),Ref (StdVec CDouble),CDouble]
-extern "C"
-void
-    casadi__DpleSolver__periodic_schur__1(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5, double x6);
-void
-    casadi__DpleSolver__periodic_schur__1(std::string ** err_msg, std::string* x0, std::vector< casadi::DMatrix* >* x1, std::vector< casadi::DMatrix* >* x2, std::vector< casadi::DMatrix* >* x3, std::vector< double >* x4, std::vector< double >* x5, double x6){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< casadi::DMatrix > x2_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x2);
-        std::vector< casadi::DMatrix > x3_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x3);
-        std::vector< double > x4_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x4);
-        std::vector< double > x5_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x5);
-        double x6_ = Marshaling<double,double>::marshal(x6);
-
-        casadi::DpleSolver::periodic_schur(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printStats" ===============
-// class: "casadi::DpleSolver"
-// cppName: "casadi::DpleSolver::printStats"
-// cWrapperName: "casadi__DpleSolver__printStats"
-// protoArgs: "(std::string ** err_msg, casadi::DpleSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__DpleSolver__printStats(std::string ** err_msg, casadi::DpleSolver* obj)"
-// call: "obj->printStats()"
-// params: []
-extern "C"
-void
-    casadi__DpleSolver__printStats(std::string ** err_msg, casadi::DpleSolver* obj);
-void
-    casadi__DpleSolver__printStats(std::string ** err_msg, casadi::DpleSolver* obj){
-    try {
-
-        obj->printStats();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "ExternalFunction")===============
-// classType: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-extern "C"
-void delete_casadi__ExternalFunction(casadi::ExternalFunction* obj);
-void delete_casadi__ExternalFunction(casadi::ExternalFunction* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ExternalFunction"
-// cppName: "casadi::ExternalFunction"
-// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Compiler* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-// cWrapperRetType: "casadi::ExternalFunction*"
-// proto: "casadi::ExternalFunction*\n    casadi__ExternalFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Compiler* x1)"
-// call: "casadi::ExternalFunction(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Compiler")))]
-extern "C"
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Compiler* x1);
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Compiler* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Compiler& x1_ = Marshaling<casadi::Compiler&,casadi::Compiler*>::marshal(x1);
-
-        return new casadi::ExternalFunction(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ExternalFunction"
-// cppName: "casadi::ExternalFunction"
-// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Compiler* x1, std::map< std::string, casadi::GenericType* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-// cWrapperRetType: "casadi::ExternalFunction*"
-// proto: "casadi::ExternalFunction*\n    casadi__ExternalFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Compiler* x1, std::map< std::string, casadi::GenericType* >* x2)"
-// call: "casadi::ExternalFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Compiler"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Compiler* x1, std::map< std::string, casadi::GenericType* >* x2);
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Compiler* x1, std::map< std::string, casadi::GenericType* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Compiler& x1_ = Marshaling<casadi::Compiler&,casadi::Compiler*>::marshal(x1);
-        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
-
-        return new casadi::ExternalFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ExternalFunction"
-// cppName: "casadi::ExternalFunction"
-// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-// cWrapperRetType: "casadi::ExternalFunction*"
-// proto: "casadi::ExternalFunction*\n    casadi__ExternalFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1)"
-// call: "casadi::ExternalFunction(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1);
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        return new casadi::ExternalFunction(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ExternalFunction"
-// cppName: "casadi::ExternalFunction"
-// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-// cWrapperRetType: "casadi::ExternalFunction*"
-// proto: "casadi::ExternalFunction*\n    casadi__ExternalFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2)"
-// call: "casadi::ExternalFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2);
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
-
-        return new casadi::ExternalFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ExternalFunction"
-// cppName: "casadi::ExternalFunction"
-// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-// cWrapperRetType: "casadi::ExternalFunction*"
-// proto: "casadi::ExternalFunction*\n    casadi__ExternalFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0)"
-// call: "casadi::ExternalFunction(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0);
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        return new casadi::ExternalFunction(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ExternalFunction"
-// cppName: "casadi::ExternalFunction"
-// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-// cWrapperRetType: "casadi::ExternalFunction*"
-// proto: "casadi::ExternalFunction*\n    casadi__ExternalFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
-// call: "casadi::ExternalFunction(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
-
-        return new casadi::ExternalFunction(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ExternalFunction"
-// cppName: "casadi::ExternalFunction"
-// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
-// cWrapperRetType: "casadi::ExternalFunction*"
-// proto: "casadi::ExternalFunction*\n    casadi__ExternalFunction__CONSTRUCTOR__6(std::string ** err_msg)"
-// call: "casadi::ExternalFunction()"
-// params: []
-extern "C"
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__6(std::string ** err_msg);
-casadi::ExternalFunction*
-    casadi__ExternalFunction__CONSTRUCTOR__6(std::string ** err_msg){
-    try {
-
-        return new casadi::ExternalFunction();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Function")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Function")
-extern "C"
-void delete_casadi__Function(casadi::Function* obj);
-void delete_casadi__Function(casadi::Function* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function"
-// cWrapperName: "casadi__Function__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::Function()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Function__CONSTRUCTOR(std::string ** err_msg);
-casadi::Function*
-    casadi__Function__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::Function();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "addMonitor" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::addMonitor"
-// cWrapperName: "casadi__Function__addMonitor"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->addMonitor(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-void
-    casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->addMonitor(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
-// call: "obj->call(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1);
-void
-    casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-
-        obj->call(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2)"
-// call: "obj->call(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
-extern "C"
-void
-    casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2);
-void
-    casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->call(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2, int x3)"
-// call: "obj->call(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2, int x3);
-void
-    casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, int x2, int x3){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->call(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1)"
-// call: "obj->call(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-void
-    casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1);
-void
-    casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-
-        obj->call(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2)"
-// call: "obj->call(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),CBool]
-extern "C"
-void
-    casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2);
-void
-    casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->call(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2, int x3)"
-// call: "obj->call(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2, int x3);
-void
-    casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, int x2, int x3){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->call(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1)"
-// call: "obj->call(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1);
-void
-    casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-
-        obj->call(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2)"
-// call: "obj->call(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool]
-extern "C"
-void
-    casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2);
-void
-    casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->call(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "call" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::call"
-// cWrapperName: "casadi__Function__call__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2, int x3)"
-// call: "obj->call(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2, int x3);
-void
-    casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, int x2, int x3){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->call(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-void
-    casadi__Function__callDerivative__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5);
-void
-    casadi__Function__callDerivative__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::MX > > x5_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x5);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool]
-extern "C"
-void
-    casadi__Function__callDerivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6);
-void
-    casadi__Function__callDerivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::MX > > x5_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x5);
-        bool x6_ = Marshaling<bool,int>::marshal(x6);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callDerivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7);
-void
-    casadi__Function__callDerivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::MX > > x5_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x5);
-        bool x6_ = Marshaling<bool,int>::marshal(x6);
-        bool x7_ = Marshaling<bool,int>::marshal(x7);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-void
-    casadi__Function__callDerivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5);
-void
-    casadi__Function__callDerivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::SX > > x5_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x5);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool]
-extern "C"
-void
-    casadi__Function__callDerivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6);
-void
-    casadi__Function__callDerivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::SX > > x5_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x5);
-        bool x6_ = Marshaling<bool,int>::marshal(x6);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callDerivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7);
-void
-    casadi__Function__callDerivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::SX > > x5_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x5);
-        bool x6_ = Marshaling<bool,int>::marshal(x6);
-        bool x7_ = Marshaling<bool,int>::marshal(x7);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
-extern "C"
-void
-    casadi__Function__callDerivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5);
-void
-    casadi__Function__callDerivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::DMatrix > > x4_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::DMatrix > > x5_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x5);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool]
-extern "C"
-void
-    casadi__Function__callDerivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6);
-void
-    casadi__Function__callDerivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::DMatrix > > x4_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::DMatrix > > x5_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x5);
-        bool x6_ = Marshaling<bool,int>::marshal(x6);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callDerivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callDerivative"
-// cWrapperName: "casadi__Function__callDerivative__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callDerivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7)"
-// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callDerivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7);
-void
-    casadi__Function__callDerivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-        std::vector< std::vector< casadi::DMatrix > > x4_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x4);
-        std::vector< std::vector< casadi::DMatrix > > x5_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x5);
-        bool x6_ = Marshaling<bool,int>::marshal(x6);
-        bool x7_ = Marshaling<bool,int>::marshal(x7);
-
-        obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
-extern "C"
-void
-    casadi__Function__callForward__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3);
-void
-    casadi__Function__callForward__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-
-        obj->callForward(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool]
-extern "C"
-void
-    casadi__Function__callForward__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4);
-void
-    casadi__Function__callForward__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->callForward(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callForward__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5);
-void
-    casadi__Function__callForward__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        obj->callForward(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-void
-    casadi__Function__callForward__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3);
-void
-    casadi__Function__callForward__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-
-        obj->callForward(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool]
-extern "C"
-void
-    casadi__Function__callForward__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4);
-void
-    casadi__Function__callForward__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->callForward(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callForward__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5);
-void
-    casadi__Function__callForward__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        obj->callForward(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-void
-    casadi__Function__callForward__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3);
-void
-    casadi__Function__callForward__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-
-        obj->callForward(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool]
-extern "C"
-void
-    casadi__Function__callForward__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4);
-void
-    casadi__Function__callForward__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->callForward(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callForward"
-// cWrapperName: "casadi__Function__callForward__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callForward__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5)"
-// call: "obj->callForward(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callForward__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5);
-void
-    casadi__Function__callForward__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        obj->callForward(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
-extern "C"
-void
-    casadi__Function__callReverse__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3);
-void
-    casadi__Function__callReverse__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-
-        obj->callReverse(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool]
-extern "C"
-void
-    casadi__Function__callReverse__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4);
-void
-    casadi__Function__callReverse__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->callReverse(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callReverse__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5);
-void
-    casadi__Function__callReverse__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, int x4, int x5){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
-        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        obj->callReverse(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-void
-    casadi__Function__callReverse__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3);
-void
-    casadi__Function__callReverse__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-
-        obj->callReverse(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool]
-extern "C"
-void
-    casadi__Function__callReverse__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4);
-void
-    casadi__Function__callReverse__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->callReverse(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callReverse__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5);
-void
-    casadi__Function__callReverse__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, int x4, int x5){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        obj->callReverse(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-void
-    casadi__Function__callReverse__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3);
-void
-    casadi__Function__callReverse__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-
-        obj->callReverse(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool]
-extern "C"
-void
-    casadi__Function__callReverse__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4);
-void
-    casadi__Function__callReverse__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->callReverse(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "callReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::callReverse"
-// cWrapperName: "casadi__Function__callReverse__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__callReverse__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5)"
-// call: "obj->callReverse(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool,CBool]
-extern "C"
-void
-    casadi__Function__callReverse__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5);
-void
-    casadi__Function__callReverse__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, int x4, int x5){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
-        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        obj->callReverse(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "checkInputs" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::checkInputs"
-// cWrapperName: "casadi__Function__checkInputs"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->checkInputs()"
-// params: []
-extern "C"
-void
-    casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj);
-void
-    casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        obj->checkInputs();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "defaultInput" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::defaultInput"
-// cWrapperName: "casadi__Function__defaultInput"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__Function__defaultInput(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->defaultInput(x0_)"
-// params: [CInt]
-extern "C"
-double
-    casadi__Function__defaultInput(std::string ** err_msg, casadi::Function* obj, int x0);
-double
-    casadi__Function__defaultInput(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        double ret = obj->defaultInput(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "derForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::derForward"
-// cWrapperName: "casadi__Function__derForward"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__derForward(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->derForward(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__derForward(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Function*
-    casadi__Function__derForward(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Function ret = obj->derForward(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "derReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::derReverse"
-// cWrapperName: "casadi__Function__derReverse"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__derReverse(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->derReverse(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__derReverse(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Function*
-    casadi__Function__derReverse(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Function ret = obj->derReverse(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "derivative" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::derivative"
-// cWrapperName: "casadi__Function__derivative"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__derivative(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// call: "obj->derivative(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__derivative(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
-casadi::Function*
-    casadi__Function__derivative(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->derivative(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "evaluate" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::evaluate"
-// cWrapperName: "casadi__Function__evaluate"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__evaluate(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->evaluate()"
-// params: []
-extern "C"
-void
-    casadi__Function__evaluate(std::string ** err_msg, casadi::Function* obj);
-void
-    casadi__Function__evaluate(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        obj->evaluate();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "fullJacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::fullJacobian"
-// cWrapperName: "casadi__Function__fullJacobian"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->fullJacobian()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj);
-casadi::Function*
-    casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Function ret = obj->fullJacobian();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "generate" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::generate"
-// cWrapperName: "casadi__Function__generate__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__generate__0(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->generate()"
-// params: []
-extern "C"
-void
-    casadi__Function__generate__0(std::string ** err_msg, casadi::Function* obj);
-void
-    casadi__Function__generate__0(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        obj->generate();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "generate" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::generate"
-// cWrapperName: "casadi__Function__generate__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__generate__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0)"
-// call: "obj->generate(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-void
-    casadi__Function__generate__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0);
-void
-    casadi__Function__generate__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0){
-    try {
-        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
-
-        obj->generate(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "generate" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::generate"
-// cWrapperName: "casadi__Function__generate__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__generate__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->generate(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__Function__generate__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-void
-    casadi__Function__generate__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->generate(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "generate" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::generate"
-// cWrapperName: "casadi__Function__generate__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__generate__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
-// call: "obj->generate(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-void
-    casadi__Function__generate__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
-void
-    casadi__Function__generate__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
-
-        obj->generate(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getSanitizedName" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::getSanitizedName"
-// cWrapperName: "casadi__Function__getSanitizedName"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Function__getSanitizedName(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->getSanitizedName()"
-// params: []
-extern "C"
-std::string*
-    casadi__Function__getSanitizedName(std::string ** err_msg, casadi::Function* obj);
-std::string*
-    casadi__Function__getSanitizedName(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        std::string ret = obj->getSanitizedName();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getStat" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::getStat"
-// cWrapperName: "casadi__Function__getStat"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__Function__getStat(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->getStat(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::GenericType*
-    casadi__Function__getStat(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::GenericType*
-    casadi__Function__getStat(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::GenericType ret = obj->getStat(x0_);
-        return WrapReturn< casadi::GenericType*, casadi::GenericType >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getStats" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::getStats"
-// cWrapperName: "casadi__Function__getStats"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))
-// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
-// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__Function__getStats(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->getStats()"
-// params: []
-extern "C"
-std::map< std::string, casadi::GenericType* >*
-    casadi__Function__getStats(std::string ** err_msg, casadi::Function* obj);
-std::map< std::string, casadi::GenericType* >*
-    casadi__Function__getStats(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        std::map< std::string, casadi::GenericType > ret = obj->getStats();
-        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradient" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::gradient"
-// cWrapperName: "casadi__Function__gradient__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// call: "obj->gradient(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
-casadi::Function*
-    casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->gradient(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradient" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::gradient"
-// cWrapperName: "casadi__Function__gradient__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// call: "obj->gradient(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
-casadi::Function*
-    casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->gradient(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradient" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::gradient"
-// cWrapperName: "casadi__Function__gradient__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->gradient(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::Function*
-    casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Function ret = obj->gradient(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradient" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::gradient"
-// cWrapperName: "casadi__Function__gradient__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// call: "obj->gradient(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
-casadi::Function*
-    casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->gradient(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradient" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::gradient"
-// cWrapperName: "casadi__Function__gradient__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->gradient()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj);
-casadi::Function*
-    casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Function ret = obj->gradient();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradient" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::gradient"
-// cWrapperName: "casadi__Function__gradient__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->gradient(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Function*
-    casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Function ret = obj->gradient(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradient" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::gradient"
-// cWrapperName: "casadi__Function__gradient__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// call: "obj->gradient(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
-casadi::Function*
-    casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->gradient(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::hessian"
-// cWrapperName: "casadi__Function__hessian__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// call: "obj->hessian(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
-casadi::Function*
-    casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->hessian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::hessian"
-// cWrapperName: "casadi__Function__hessian__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// call: "obj->hessian(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
-casadi::Function*
-    casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->hessian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::hessian"
-// cWrapperName: "casadi__Function__hessian__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->hessian(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::Function*
-    casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Function ret = obj->hessian(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::hessian"
-// cWrapperName: "casadi__Function__hessian__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// call: "obj->hessian(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
-casadi::Function*
-    casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->hessian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::hessian"
-// cWrapperName: "casadi__Function__hessian__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->hessian()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj);
-casadi::Function*
-    casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Function ret = obj->hessian();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::hessian"
-// cWrapperName: "casadi__Function__hessian__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->hessian(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Function*
-    casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Function ret = obj->hessian(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::hessian"
-// cWrapperName: "casadi__Function__hessian__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// call: "obj->hessian(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
-casadi::Function*
-    casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->hessian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputDescription" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::inputDescription"
-// cWrapperName: "casadi__Function__inputDescription"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Function__inputDescription(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->inputDescription(x0_)"
-// params: [CInt]
-extern "C"
-std::string*
-    casadi__Function__inputDescription(std::string ** err_msg, casadi::Function* obj, int x0);
-std::string*
-    casadi__Function__inputDescription(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::string ret = obj->inputDescription(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputIndex" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::inputIndex"
-// cWrapperName: "casadi__Function__inputIndex"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__inputIndex(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->inputIndex(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__Function__inputIndex(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-int
-    casadi__Function__inputIndex(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        int ret = obj->inputIndex(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputName" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::inputName"
-// cWrapperName: "casadi__Function__inputName"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Function__inputName(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->inputName(x0_)"
-// params: [CInt]
-extern "C"
-std::string*
-    casadi__Function__inputName(std::string ** err_msg, casadi::Function* obj, int x0);
-std::string*
-    casadi__Function__inputName(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::string ret = obj->inputName(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputScheme" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::inputScheme"
-// cWrapperName: "casadi__Function__inputScheme"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: StdVec StdString
-// cWrapperRetType: "std::vector< std::string* >*"
-// proto: "std::vector< std::string* >*\n    casadi__Function__inputScheme(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->inputScheme()"
-// params: []
-extern "C"
-std::vector< std::string* >*
-    casadi__Function__inputScheme(std::string ** err_msg, casadi::Function* obj);
-std::vector< std::string* >*
-    casadi__Function__inputScheme(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        std::vector< std::string > ret = obj->inputScheme();
-        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::inputSparsity"
-// cWrapperName: "casadi__Function__inputSparsity__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__inputSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->inputSparsity(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__inputSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::Sparsity*
-    casadi__Function__inputSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->inputSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::inputSparsity"
-// cWrapperName: "casadi__Function__inputSparsity__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__inputSparsity__1(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->inputSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Function__inputSparsity__1(std::string ** err_msg, casadi::Function* obj);
-casadi::Sparsity*
-    casadi__Function__inputSparsity__1(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Sparsity ret = obj->inputSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::inputSparsity"
-// cWrapperName: "casadi__Function__inputSparsity__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__inputSparsity__2(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->inputSparsity(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__inputSparsity__2(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Sparsity*
-    casadi__Function__inputSparsity__2(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->inputSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// call: "obj->jacSparsity(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
-// call: "obj->jacSparsity(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// call: "obj->jacSparsity(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
-// call: "obj->jacSparsity(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const StdString),CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
-// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
-// params: [CInt,Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__6(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->jacSparsity(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__6(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__6(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// call: "obj->jacSparsity(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
-// call: "obj->jacSparsity(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__9"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
-// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CBool,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__10"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__10(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->jacSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__10(std::string ** err_msg, casadi::Function* obj);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__10(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Sparsity ret = obj->jacSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__11"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__11(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->jacSparsity(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__11(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__11(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__12"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// call: "obj->jacSparsity(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__13"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
-// call: "obj->jacSparsity(x0_, x1_, x2_)"
-// params: [CInt,CInt,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacSparsity"
-// cWrapperName: "casadi__Function__jacSparsity__14"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__jacSparsity__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
-// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,CBool,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__jacSparsity__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3);
-casadi::Sparsity*
-    casadi__Function__jacSparsity__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Sparsity ret = obj->jacSparsity(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// call: "obj->jacobian(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
-casadi::Function*
-    casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
-// call: "obj->jacobian(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2);
-casadi::Function*
-    casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
-casadi::Function*
-    casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// call: "obj->jacobian(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
-casadi::Function*
-    casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
-// call: "obj->jacobian(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const StdString),CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2);
-casadi::Function*
-    casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
-// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
-// params: [CInt,Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3);
-casadi::Function*
-    casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->jacobian(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::Function*
-    casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Function ret = obj->jacobian(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// call: "obj->jacobian(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
-casadi::Function*
-    casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
-// call: "obj->jacobian(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2);
-casadi::Function*
-    casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__9"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
-// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CBool,CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3);
-casadi::Function*
-    casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__10"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->jacobian()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj);
-casadi::Function*
-    casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Function ret = obj->jacobian();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__11"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->jacobian(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Function*
-    casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Function ret = obj->jacobian(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__12"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// call: "obj->jacobian(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
-casadi::Function*
-    casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__13"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
-// call: "obj->jacobian(x0_, x1_, x2_)"
-// params: [CInt,CInt,CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2);
-casadi::Function*
-    casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::jacobian"
-// cWrapperName: "casadi__Function__jacobian__14"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
-// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,CBool,CBool]
-extern "C"
-casadi::Function*
-    casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3);
-casadi::Function*
-    casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "map" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::map"
-// cWrapperName: "casadi__Function__map__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__map__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// call: "obj->map(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__map__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
-casadi::Function*
-    casadi__Function__map__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->map(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "map" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::map"
-// cWrapperName: "casadi__Function__map__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__map__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
-// call: "obj->map(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Function*
-    casadi__Function__map__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2);
-casadi::Function*
-    casadi__Function__map__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
-
-        casadi::Function ret = obj->map(x0_, x1_, x2_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "map" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::map"
-// cWrapperName: "casadi__Function__map__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__map__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
-// call: "obj->map(x0_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__map__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0);
-std::vector< casadi::MX* >*
-    casadi__Function__map__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-
-        std::vector< casadi::MX > ret = obj->map(x0_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "map" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::map"
-// cWrapperName: "casadi__Function__map__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__map__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
-// call: "obj->map(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__map__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1);
-std::vector< casadi::MX* >*
-    casadi__Function__map__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        std::vector< casadi::MX > ret = obj->map(x0_, x1_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "map" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::map"
-// cWrapperName: "casadi__Function__map__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0)"
-// args: "(x0_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
-// proto: "std::vector< std::vector< casadi::MX* >* >*\n    casadi__Function__map__4(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0)"
-// call: "obj->map(x0_)"
-// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))))]
-extern "C"
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__Function__map__4(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0);
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__Function__map__4(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0){
-    try {
-        std::vector< std::vector< casadi::MX > > x0_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x0);
-
-        std::vector< std::vector< casadi::MX > > ret = obj->map(x0_);
-        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "map" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::map"
-// cWrapperName: "casadi__Function__map__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
-// proto: "std::vector< std::vector< casadi::MX* >* >*\n    casadi__Function__map__5(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0, std::string* x1)"
-// call: "obj->map(x0_, x1_)"
-// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (Const StdString)]
-extern "C"
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__Function__map__5(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0, std::string* x1);
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__Function__map__5(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0, std::string* x1){
-    try {
-        std::vector< std::vector< casadi::MX > > x0_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        std::vector< std::vector< casadi::MX > > ret = obj->map(x0_, x1_);
-        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "mapaccum" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::mapaccum"
-// cWrapperName: "casadi__Function__mapaccum__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__mapaccum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// call: "obj->mapaccum(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__mapaccum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
-casadi::Function*
-    casadi__Function__mapaccum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->mapaccum(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "mapaccum" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::mapaccum"
-// cWrapperName: "casadi__Function__mapaccum__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__mapaccum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
-// call: "obj->mapaccum(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Function*
-    casadi__Function__mapaccum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2);
-casadi::Function*
-    casadi__Function__mapaccum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
-
-        casadi::Function ret = obj->mapaccum(x0_, x1_, x2_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "mapsum" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::mapsum"
-// cWrapperName: "casadi__Function__mapsum__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__mapsum__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
-// call: "obj->mapsum(x0_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__mapsum__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0);
-std::vector< casadi::MX* >*
-    casadi__Function__mapsum__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-
-        std::vector< casadi::MX > ret = obj->mapsum(x0_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "mapsum" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::mapsum"
-// cWrapperName: "casadi__Function__mapsum__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__mapsum__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
-// call: "obj->mapsum(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__mapsum__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1);
-std::vector< casadi::MX* >*
-    casadi__Function__mapsum__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        std::vector< casadi::MX > ret = obj->mapsum(x0_, x1_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nIn" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::nIn"
-// cWrapperName: "casadi__Function__nIn"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__nIn(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->nIn()"
-// params: []
-extern "C"
-int
-    casadi__Function__nIn(std::string ** err_msg, casadi::Function* obj);
-int
-    casadi__Function__nIn(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        int ret = obj->nIn();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nOut" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::nOut"
-// cWrapperName: "casadi__Function__nOut"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__nOut(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->nOut()"
-// params: []
-extern "C"
-int
-    casadi__Function__nOut(std::string ** err_msg, casadi::Function* obj);
-int
-    casadi__Function__nOut(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        int ret = obj->nOut();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nnzIn" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::nnzIn"
-// cWrapperName: "casadi__Function__nnzIn"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__nnzIn(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->nnzIn()"
-// params: []
-extern "C"
-int
-    casadi__Function__nnzIn(std::string ** err_msg, casadi::Function* obj);
-int
-    casadi__Function__nnzIn(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        int ret = obj->nnzIn();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nnzOut" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::nnzOut"
-// cWrapperName: "casadi__Function__nnzOut"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__nnzOut(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->nnzOut()"
-// params: []
-extern "C"
-int
-    casadi__Function__nnzOut(std::string ** err_msg, casadi::Function* obj);
-int
-    casadi__Function__nnzOut(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        int ret = obj->nnzOut();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numelIn" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::numelIn"
-// cWrapperName: "casadi__Function__numelIn"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__numelIn(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->numelIn()"
-// params: []
-extern "C"
-int
-    casadi__Function__numelIn(std::string ** err_msg, casadi::Function* obj);
-int
-    casadi__Function__numelIn(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        int ret = obj->numelIn();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numelOut" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::numelOut"
-// cWrapperName: "casadi__Function__numelOut"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__numelOut(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->numelOut()"
-// params: []
-extern "C"
-int
-    casadi__Function__numelOut(std::string ** err_msg, casadi::Function* obj);
-int
-    casadi__Function__numelOut(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        int ret = obj->numelOut();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0)"
-// args: "(x0_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::map< std::string, casadi::MX* >*"
-// proto: "std::map< std::string, casadi::MX* >*\n    casadi__Function__operator_call__0(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-std::map< std::string, casadi::MX* >*
-    casadi__Function__operator_call__0(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0);
-std::map< std::string, casadi::MX* >*
-    casadi__Function__operator_call__0(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0){
-    try {
-        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
-
-        std::map< std::string, casadi::MX > ret = obj->operator ()(x0_);
-        return WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::map< std::string, casadi::MX* >*"
-// proto: "std::map< std::string, casadi::MX* >*\n    casadi__Function__operator_call__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1)"
-// call: "obj->operator ()(x0_, x1_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),CBool]
-extern "C"
-std::map< std::string, casadi::MX* >*
-    casadi__Function__operator_call__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1);
-std::map< std::string, casadi::MX* >*
-    casadi__Function__operator_call__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1){
-    try {
-        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::map< std::string, casadi::MX > ret = obj->operator ()(x0_, x1_);
-        return WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::map< std::string, casadi::MX* >*"
-// proto: "std::map< std::string, casadi::MX* >*\n    casadi__Function__operator_call__2(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1, int x2)"
-// call: "obj->operator ()(x0_, x1_, x2_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),CBool,CBool]
-extern "C"
-std::map< std::string, casadi::MX* >*
-    casadi__Function__operator_call__2(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1, int x2);
-std::map< std::string, casadi::MX* >*
-    casadi__Function__operator_call__2(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, int x1, int x2){
-    try {
-        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        std::map< std::string, casadi::MX > ret = obj->operator ()(x0_, x1_, x2_);
-        return WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0)"
-// args: "(x0_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))
-// cWrapperRetType: "std::map< std::string, casadi::SX* >*"
-// proto: "std::map< std::string, casadi::SX* >*\n    casadi__Function__operator_call__3(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-std::map< std::string, casadi::SX* >*
-    casadi__Function__operator_call__3(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0);
-std::map< std::string, casadi::SX* >*
-    casadi__Function__operator_call__3(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0){
-    try {
-        std::map< std::string, casadi::SX > x0_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x0);
-
-        std::map< std::string, casadi::SX > ret = obj->operator ()(x0_);
-        return WrapReturn< std::map< std::string, casadi::SX* >*, std::map< std::string, casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))
-// cWrapperRetType: "std::map< std::string, casadi::SX* >*"
-// proto: "std::map< std::string, casadi::SX* >*\n    casadi__Function__operator_call__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1)"
-// call: "obj->operator ()(x0_, x1_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),CBool]
-extern "C"
-std::map< std::string, casadi::SX* >*
-    casadi__Function__operator_call__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1);
-std::map< std::string, casadi::SX* >*
-    casadi__Function__operator_call__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1){
-    try {
-        std::map< std::string, casadi::SX > x0_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::map< std::string, casadi::SX > ret = obj->operator ()(x0_, x1_);
-        return WrapReturn< std::map< std::string, casadi::SX* >*, std::map< std::string, casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))
-// cWrapperRetType: "std::map< std::string, casadi::SX* >*"
-// proto: "std::map< std::string, casadi::SX* >*\n    casadi__Function__operator_call__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1, int x2)"
-// call: "obj->operator ()(x0_, x1_, x2_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),CBool,CBool]
-extern "C"
-std::map< std::string, casadi::SX* >*
-    casadi__Function__operator_call__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1, int x2);
-std::map< std::string, casadi::SX* >*
-    casadi__Function__operator_call__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, int x1, int x2){
-    try {
-        std::map< std::string, casadi::SX > x0_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        std::map< std::string, casadi::SX > ret = obj->operator ()(x0_, x1_, x2_);
-        return WrapReturn< std::map< std::string, casadi::SX* >*, std::map< std::string, casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0)"
-// args: "(x0_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DMatrix")))
-// cWrapperRetType: "std::map< std::string, casadi::DMatrix* >*"
-// proto: "std::map< std::string, casadi::DMatrix* >*\n    casadi__Function__operator_call__6(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
-extern "C"
-std::map< std::string, casadi::DMatrix* >*
-    casadi__Function__operator_call__6(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0);
-std::map< std::string, casadi::DMatrix* >*
-    casadi__Function__operator_call__6(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0){
-    try {
-        std::map< std::string, casadi::DMatrix > x0_ = Marshaling<std::map< std::string, casadi::DMatrix >,std::map< std::string, casadi::DMatrix* >*>::marshal(x0);
-
-        std::map< std::string, casadi::DMatrix > ret = obj->operator ()(x0_);
-        return WrapReturn< std::map< std::string, casadi::DMatrix* >*, std::map< std::string, casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DMatrix")))
-// cWrapperRetType: "std::map< std::string, casadi::DMatrix* >*"
-// proto: "std::map< std::string, casadi::DMatrix* >*\n    casadi__Function__operator_call__7(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1)"
-// call: "obj->operator ()(x0_, x1_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool]
-extern "C"
-std::map< std::string, casadi::DMatrix* >*
-    casadi__Function__operator_call__7(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1);
-std::map< std::string, casadi::DMatrix* >*
-    casadi__Function__operator_call__7(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1){
-    try {
-        std::map< std::string, casadi::DMatrix > x0_ = Marshaling<std::map< std::string, casadi::DMatrix >,std::map< std::string, casadi::DMatrix* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::map< std::string, casadi::DMatrix > ret = obj->operator ()(x0_, x1_);
-        return WrapReturn< std::map< std::string, casadi::DMatrix* >*, std::map< std::string, casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DMatrix")))
-// cWrapperRetType: "std::map< std::string, casadi::DMatrix* >*"
-// proto: "std::map< std::string, casadi::DMatrix* >*\n    casadi__Function__operator_call__8(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1, int x2)"
-// call: "obj->operator ()(x0_, x1_, x2_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool,CBool]
-extern "C"
-std::map< std::string, casadi::DMatrix* >*
-    casadi__Function__operator_call__8(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1, int x2);
-std::map< std::string, casadi::DMatrix* >*
-    casadi__Function__operator_call__8(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DMatrix* >* x0, int x1, int x2){
-    try {
-        std::map< std::string, casadi::DMatrix > x0_ = Marshaling<std::map< std::string, casadi::DMatrix >,std::map< std::string, casadi::DMatrix* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        std::map< std::string, casadi::DMatrix > ret = obj->operator ()(x0_, x1_, x2_);
-        return WrapReturn< std::map< std::string, casadi::DMatrix* >*, std::map< std::string, casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__9"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__operator_call__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__operator_call__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0);
-std::vector< casadi::MX* >*
-    casadi__Function__operator_call__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-
-        std::vector< casadi::MX > ret = obj->operator ()(x0_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__10"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__operator_call__10(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1)"
-// call: "obj->operator ()(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__operator_call__10(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1);
-std::vector< casadi::MX* >*
-    casadi__Function__operator_call__10(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< casadi::MX > ret = obj->operator ()(x0_, x1_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__11"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__operator_call__11(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2)"
-// call: "obj->operator ()(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool,CBool]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__operator_call__11(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2);
-std::vector< casadi::MX* >*
-    casadi__Function__operator_call__11(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        std::vector< casadi::MX > ret = obj->operator ()(x0_, x1_, x2_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__12"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__Function__operator_call__12(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__Function__operator_call__12(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0);
-std::vector< casadi::SX* >*
-    casadi__Function__operator_call__12(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-
-        std::vector< casadi::SX > ret = obj->operator ()(x0_);
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__13"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__Function__operator_call__13(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1)"
-// call: "obj->operator ()(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool]
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__Function__operator_call__13(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1);
-std::vector< casadi::SX* >*
-    casadi__Function__operator_call__13(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< casadi::SX > ret = obj->operator ()(x0_, x1_);
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__14"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__Function__operator_call__14(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2)"
-// call: "obj->operator ()(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool,CBool]
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__Function__operator_call__14(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2);
-std::vector< casadi::SX* >*
-    casadi__Function__operator_call__14(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        std::vector< casadi::SX > ret = obj->operator ()(x0_, x1_, x2_);
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__15"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
-// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
-// proto: "std::vector< casadi::DMatrix* >*\n    casadi__Function__operator_call__15(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
-extern "C"
-std::vector< casadi::DMatrix* >*
-    casadi__Function__operator_call__15(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0);
-std::vector< casadi::DMatrix* >*
-    casadi__Function__operator_call__15(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-
-        std::vector< casadi::DMatrix > ret = obj->operator ()(x0_);
-        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__16"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
-// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
-// proto: "std::vector< casadi::DMatrix* >*\n    casadi__Function__operator_call__16(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1)"
-// call: "obj->operator ()(x0_, x1_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool]
-extern "C"
-std::vector< casadi::DMatrix* >*
-    casadi__Function__operator_call__16(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1);
-std::vector< casadi::DMatrix* >*
-    casadi__Function__operator_call__16(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< casadi::DMatrix > ret = obj->operator ()(x0_, x1_);
-        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::operator ()"
-// cWrapperName: "casadi__Function__operator_call__17"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
-// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
-// proto: "std::vector< casadi::DMatrix* >*\n    casadi__Function__operator_call__17(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2)"
-// call: "obj->operator ()(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool,CBool]
-extern "C"
-std::vector< casadi::DMatrix* >*
-    casadi__Function__operator_call__17(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2);
-std::vector< casadi::DMatrix* >*
-    casadi__Function__operator_call__17(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2){
-    try {
-        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        std::vector< casadi::DMatrix > ret = obj->operator ()(x0_, x1_, x2_);
-        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputDescription" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::outputDescription"
-// cWrapperName: "casadi__Function__outputDescription"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Function__outputDescription(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->outputDescription(x0_)"
-// params: [CInt]
-extern "C"
-std::string*
-    casadi__Function__outputDescription(std::string ** err_msg, casadi::Function* obj, int x0);
-std::string*
-    casadi__Function__outputDescription(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::string ret = obj->outputDescription(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputIndex" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::outputIndex"
-// cWrapperName: "casadi__Function__outputIndex"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__outputIndex(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->outputIndex(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__Function__outputIndex(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-int
-    casadi__Function__outputIndex(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        int ret = obj->outputIndex(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputName" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::outputName"
-// cWrapperName: "casadi__Function__outputName"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Function__outputName(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->outputName(x0_)"
-// params: [CInt]
-extern "C"
-std::string*
-    casadi__Function__outputName(std::string ** err_msg, casadi::Function* obj, int x0);
-std::string*
-    casadi__Function__outputName(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::string ret = obj->outputName(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputScheme" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::outputScheme"
-// cWrapperName: "casadi__Function__outputScheme"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: StdVec StdString
-// cWrapperRetType: "std::vector< std::string* >*"
-// proto: "std::vector< std::string* >*\n    casadi__Function__outputScheme(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->outputScheme()"
-// params: []
-extern "C"
-std::vector< std::string* >*
-    casadi__Function__outputScheme(std::string ** err_msg, casadi::Function* obj);
-std::vector< std::string* >*
-    casadi__Function__outputScheme(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        std::vector< std::string > ret = obj->outputScheme();
-        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::outputSparsity"
-// cWrapperName: "casadi__Function__outputSparsity__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__outputSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->outputSparsity(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__outputSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::Sparsity*
-    casadi__Function__outputSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->outputSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::outputSparsity"
-// cWrapperName: "casadi__Function__outputSparsity__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__outputSparsity__1(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->outputSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Function__outputSparsity__1(std::string ** err_msg, casadi::Function* obj);
-casadi::Sparsity*
-    casadi__Function__outputSparsity__1(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Sparsity ret = obj->outputSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::outputSparsity"
-// cWrapperName: "casadi__Function__outputSparsity__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Function__outputSparsity__2(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->outputSparsity(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Function__outputSparsity__2(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Sparsity*
-    casadi__Function__outputSparsity__2(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->outputSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "printDimensions" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::printDimensions"
-// cWrapperName: "casadi__Function__printDimensions"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__printDimensions(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->printDimensions()"
-// params: []
-extern "C"
-void
-    casadi__Function__printDimensions(std::string ** err_msg, casadi::Function* obj);
-void
-    casadi__Function__printDimensions(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        obj->printDimensions();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "removeMonitor" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::removeMonitor"
-// cWrapperName: "casadi__Function__removeMonitor"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->removeMonitor(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-void
-    casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->removeMonitor(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "sanitizeName" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::sanitizeName"
-// cWrapperName: "casadi__Function__sanitizeName"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Function__sanitizeName(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Function::sanitizeName(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__Function__sanitizeName(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__Function__sanitizeName(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::Function::sanitizeName(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "setDerForward" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setDerForward"
-// cWrapperName: "casadi__Function__setDerForward"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setDerForward(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
-// call: "obj->setDerForward(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt]
-extern "C"
-void
-    casadi__Function__setDerForward(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1);
-void
-    casadi__Function__setDerForward(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setDerForward(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setDerReverse" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setDerReverse"
-// cWrapperName: "casadi__Function__setDerReverse"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setDerReverse(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
-// call: "obj->setDerReverse(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt]
-extern "C"
-void
-    casadi__Function__setDerReverse(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1);
-void
-    casadi__Function__setDerReverse(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setDerReverse(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setFullJacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setFullJacobian"
-// cWrapperName: "casadi__Function__setFullJacobian"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
-// call: "obj->setFullJacobian(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-void
-    casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0);
-void
-    casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-
-        obj->setFullJacobian(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-void
-    casadi__Function__setJacSparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2);
-void
-    casadi__Function__setJacSparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
-
-        obj->setJacSparsity(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),Ref (Const StdString),CBool]
-extern "C"
-void
-    casadi__Function__setJacSparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3);
-void
-    casadi__Function__setJacSparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->setJacSparsity(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,Ref (Const StdString)]
-extern "C"
-void
-    casadi__Function__setJacSparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2);
-void
-    casadi__Function__setJacSparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
-
-        obj->setJacSparsity(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,Ref (Const StdString),CBool]
-extern "C"
-void
-    casadi__Function__setJacSparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3);
-void
-    casadi__Function__setJacSparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->setJacSparsity(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),CInt]
-extern "C"
-void
-    casadi__Function__setJacSparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2);
-void
-    casadi__Function__setJacSparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        obj->setJacSparsity(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),CInt,CBool]
-extern "C"
-void
-    casadi__Function__setJacSparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3);
-void
-    casadi__Function__setJacSparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->setJacSparsity(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
-extern "C"
-void
-    casadi__Function__setJacSparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2);
-void
-    casadi__Function__setJacSparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        obj->setJacSparsity(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacSparsity" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacSparsity"
-// cWrapperName: "casadi__Function__setJacSparsity__7"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacSparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3)"
-// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt,CBool]
-extern "C"
-void
-    casadi__Function__setJacSparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3);
-void
-    casadi__Function__setJacSparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->setJacSparsity(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacobian"
-// cWrapperName: "casadi__Function__setJacobian__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
-// call: "obj->setJacobian(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-void
-    casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0);
-void
-    casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-
-        obj->setJacobian(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacobian"
-// cWrapperName: "casadi__Function__setJacobian__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
-// call: "obj->setJacobian(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt]
-extern "C"
-void
-    casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1);
-void
-    casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setJacobian(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacobian"
-// cWrapperName: "casadi__Function__setJacobian__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
-// call: "obj->setJacobian(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,CInt]
-extern "C"
-void
-    casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2);
-void
-    casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        obj->setJacobian(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setJacobian" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::setJacobian"
-// cWrapperName: "casadi__Function__setJacobian__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3)"
-// call: "obj->setJacobian(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,CInt,CBool]
-extern "C"
-void
-    casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3);
-void
-    casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        obj->setJacobian(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "spCanEvaluate" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::spCanEvaluate"
-// cWrapperName: "casadi__Function__spCanEvaluate"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->spCanEvaluate(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0);
-int
-    casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->spCanEvaluate(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "spEvaluate" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::spEvaluate"
-// cWrapperName: "casadi__Function__spEvaluate"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__spEvaluate(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->spEvaluate(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__Function__spEvaluate(std::string ** err_msg, casadi::Function* obj, int x0);
-void
-    casadi__Function__spEvaluate(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->spEvaluate(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "spInit" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::spInit"
-// cWrapperName: "casadi__Function__spInit"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Function__spInit(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->spInit(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__Function__spInit(std::string ** err_msg, casadi::Function* obj, int x0);
-void
-    casadi__Function__spInit(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->spInit(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "symbolicInput" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::symbolicInput"
-// cWrapperName: "casadi__Function__symbolicInput__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__symbolicInput__0(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->symbolicInput()"
-// params: []
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__symbolicInput__0(std::string ** err_msg, casadi::Function* obj);
-std::vector< casadi::MX* >*
-    casadi__Function__symbolicInput__0(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        std::vector< casadi::MX > ret = obj->symbolicInput();
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "symbolicInput" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::symbolicInput"
-// cWrapperName: "casadi__Function__symbolicInput__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__symbolicInput__1(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->symbolicInput(x0_)"
-// params: [CBool]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__symbolicInput__1(std::string ** err_msg, casadi::Function* obj, int x0);
-std::vector< casadi::MX* >*
-    casadi__Function__symbolicInput__1(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        std::vector< casadi::MX > ret = obj->symbolicInput(x0_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "symbolicInputSX" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::symbolicInputSX"
-// cWrapperName: "casadi__Function__symbolicInputSX"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__Function__symbolicInputSX(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->symbolicInputSX()"
-// params: []
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__Function__symbolicInputSX(std::string ** err_msg, casadi::Function* obj);
-std::vector< casadi::SX* >*
-    casadi__Function__symbolicInputSX(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        std::vector< casadi::SX > ret = obj->symbolicInputSX();
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "symbolicOutput" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::symbolicOutput"
-// cWrapperName: "casadi__Function__symbolicOutput"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__Function__symbolicOutput(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->symbolicOutput()"
-// params: []
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__Function__symbolicOutput(std::string ** err_msg, casadi::Function* obj);
-std::vector< casadi::MX* >*
-    casadi__Function__symbolicOutput(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        std::vector< casadi::MX > ret = obj->symbolicOutput();
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sz_arg" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::sz_arg"
-// cWrapperName: "casadi__Function__sz_arg"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__Function__sz_arg(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->sz_arg()"
-// params: []
-extern "C"
-size_t
-    casadi__Function__sz_arg(std::string ** err_msg, casadi::Function* obj);
-size_t
-    casadi__Function__sz_arg(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        size_t ret = obj->sz_arg();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sz_iw" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::sz_iw"
-// cWrapperName: "casadi__Function__sz_iw"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__Function__sz_iw(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->sz_iw()"
-// params: []
-extern "C"
-size_t
-    casadi__Function__sz_iw(std::string ** err_msg, casadi::Function* obj);
-size_t
-    casadi__Function__sz_iw(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        size_t ret = obj->sz_iw();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sz_res" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::sz_res"
-// cWrapperName: "casadi__Function__sz_res"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__Function__sz_res(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->sz_res()"
-// params: []
-extern "C"
-size_t
-    casadi__Function__sz_res(std::string ** err_msg, casadi::Function* obj);
-size_t
-    casadi__Function__sz_res(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        size_t ret = obj->sz_res();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sz_w" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::sz_w"
-// cWrapperName: "casadi__Function__sz_w"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__Function__sz_w(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->sz_w()"
-// params: []
-extern "C"
-size_t
-    casadi__Function__sz_w(std::string ** err_msg, casadi::Function* obj);
-size_t
-    casadi__Function__sz_w(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        size_t ret = obj->sz_w();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tangent" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::tangent"
-// cWrapperName: "casadi__Function__tangent__0"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
-// call: "obj->tangent(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
-casadi::Function*
-    casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->tangent(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tangent" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::tangent"
-// cWrapperName: "casadi__Function__tangent__1"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
-// call: "obj->tangent(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
-casadi::Function*
-    casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::Function ret = obj->tangent(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tangent" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::tangent"
-// cWrapperName: "casadi__Function__tangent__2"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
-// call: "obj->tangent(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Function*
-    casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
-casadi::Function*
-    casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Function ret = obj->tangent(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tangent" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::tangent"
-// cWrapperName: "casadi__Function__tangent__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
-// call: "obj->tangent(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
-casadi::Function*
-    casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->tangent(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tangent" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::tangent"
-// cWrapperName: "casadi__Function__tangent__4"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj)"
-// call: "obj->tangent()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj);
-casadi::Function*
-    casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj){
-    try {
-
-        casadi::Function ret = obj->tangent();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tangent" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::tangent"
-// cWrapperName: "casadi__Function__tangent__5"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0)"
-// call: "obj->tangent(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0);
-casadi::Function*
-    casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Function ret = obj->tangent(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tangent" ===============
-// class: "casadi::Function"
-// cppName: "casadi::Function::tangent"
-// cWrapperName: "casadi__Function__tangent__6"
-// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
-// call: "obj->tangent(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Function*
-    casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
-casadi::Function*
-    casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Function ret = obj->tangent(x0_, x1_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Functor")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Functor")
-extern "C"
-void delete_casadi__Functor(casadi::Functor* obj);
-void delete_casadi__Functor(casadi::Functor* obj){
-    delete obj;
-}
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "GenericExpressionCommon")===============
-// classType: UserType (Namespace ["casadi"]) (Name "GenericExpressionCommon")
-extern "C"
-void delete_casadi__GenericExpressionCommon(casadi::GenericExpressionCommon* obj);
-void delete_casadi__GenericExpressionCommon(casadi::GenericExpressionCommon* obj){
-    delete obj;
-}
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "GenericMatrixCommon")===============
-// classType: UserType (Namespace ["casadi"]) (Name "GenericMatrixCommon")
-extern "C"
-void delete_casadi__GenericMatrixCommon(casadi::GenericMatrixCommon* obj);
-void delete_casadi__GenericMatrixCommon(casadi::GenericMatrixCommon* obj){
-    delete obj;
-}
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "GenericType")===============
-// classType: UserType (Namespace ["casadi"]) (Name "GenericType")
-extern "C"
-void delete_casadi__GenericType(casadi::GenericType* obj);
-void delete_casadi__GenericType(casadi::GenericType* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0){
-    try {
-        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, casadi::Callback* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::Callback* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Callback")))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::Callback* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::Callback* x0){
-    try {
-        casadi::Callback& x0_ = Marshaling<casadi::Callback&,casadi::Callback*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, casadi::DerivativeGenerator* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, casadi::DerivativeGenerator* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, casadi::DerivativeGenerator* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, casadi::DerivativeGenerator* x0){
-    try {
-        casadi::DerivativeGenerator& x0_ = Marshaling<casadi::DerivativeGenerator&,casadi::DerivativeGenerator*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::vector< std::string* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::string* >* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (StdVec StdString))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::string* >* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::string* >* x0){
-    try {
-        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< double >* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< double >* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, std::vector< std::vector< int >* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< std::vector< int >* >* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (StdVec (StdVec CInt)))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< std::vector< int >* >* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< std::vector< int >* >* x0){
-    try {
-        std::vector< std::vector< int > > x0_ = Marshaling<std::vector< std::vector< int > >,std::vector< std::vector< int >* >*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::vector< int >* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__8"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const (StdVec CBool))]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, std::vector< int >* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< bool > x0_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__9"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__10"
-// protoArgs: "(std::string ** err_msg, double x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, double x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [CDouble]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, double x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__11"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg, int x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [CInt]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg, int x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__12"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__12(std::string ** err_msg, int x0)"
-// call: "casadi::GenericType(x0_)"
-// params: [CBool]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__12(std::string ** err_msg, int x0);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__12(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        return new casadi::GenericType(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType"
-// cWrapperName: "casadi__GenericType__CONSTRUCTOR__13"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__13(std::string ** err_msg)"
-// call: "casadi::GenericType()"
-// params: []
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__13(std::string ** err_msg);
-casadi::GenericType*
-    casadi__GenericType__CONSTRUCTOR__13(std::string ** err_msg){
-    try {
-
-        return new casadi::GenericType();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "can_cast_to" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::can_cast_to"
-// cWrapperName: "casadi__GenericType__can_cast_to__0"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__can_cast_to__0(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
-// call: "obj->can_cast_to(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType")))]
-extern "C"
-int
-    casadi__GenericType__can_cast_to__0(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0);
-int
-    casadi__GenericType__can_cast_to__0(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0){
-    try {
-        casadi::GenericType& x0_ = Marshaling<casadi::GenericType&,casadi::GenericType*>::marshal(x0);
-
-        bool ret = obj->can_cast_to(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "can_cast_to" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::can_cast_to"
-// cWrapperName: "casadi__GenericType__can_cast_to__1"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__can_cast_to__1(std::string ** err_msg, casadi::GenericType* obj, int x0)"
-// call: "obj->can_cast_to(x0_)"
-// params: [CEnum (Namespace ["casadi"]) (Name "TypeID")]
-extern "C"
-int
-    casadi__GenericType__can_cast_to__1(std::string ** err_msg, casadi::GenericType* obj, int x0);
-int
-    casadi__GenericType__can_cast_to__1(std::string ** err_msg, casadi::GenericType* obj, int x0){
-    try {
-        casadi::TypeID x0_ = Marshaling<casadi::TypeID,int>::marshal(x0);
-
-        bool ret = obj->can_cast_to(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "from_type" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::from_type"
-// cWrapperName: "casadi__GenericType__from_type"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__GenericType__from_type(std::string ** err_msg, int x0)"
-// call: "casadi::GenericType::from_type(x0_)"
-// params: [CEnum (Namespace ["casadi"]) (Name "TypeID")]
-extern "C"
-casadi::GenericType*
-    casadi__GenericType__from_type(std::string ** err_msg, int x0);
-casadi::GenericType*
-    casadi__GenericType__from_type(std::string ** err_msg, int x0){
-    try {
-        casadi::TypeID x0_ = Marshaling<casadi::TypeID,int>::marshal(x0);
-
-        casadi::GenericType ret = casadi::GenericType::from_type(x0_);
-        return WrapReturn< casadi::GenericType*, casadi::GenericType >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getType" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::getType"
-// cWrapperName: "casadi__GenericType__getType"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CEnum (Namespace ["casadi"]) (Name "TypeID")
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->getType()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        casadi::TypeID ret = obj->getType();
-        return WrapReturn< int, casadi::TypeID >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "get_description" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::get_description"
-// cWrapperName: "casadi__GenericType__get_description"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->get_description()"
-// params: []
-extern "C"
-std::string*
-    casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj);
-std::string*
-    casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        std::string ret = obj->get_description();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "get_type_description" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::get_type_description"
-// cWrapperName: "casadi__GenericType__get_type_description"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__GenericType__get_type_description(std::string ** err_msg, int x0)"
-// call: "casadi::GenericType::get_type_description(x0_)"
-// params: [CEnum (Namespace ["casadi"]) (Name "TypeID")]
-extern "C"
-std::string*
-    casadi__GenericType__get_type_description(std::string ** err_msg, int x0);
-std::string*
-    casadi__GenericType__get_type_description(std::string ** err_msg, int x0){
-    try {
-        casadi::TypeID x0_ = Marshaling<casadi::TypeID,int>::marshal(x0);
-
-        std::string ret = casadi::GenericType::get_type_description(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isBool" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isBool"
-// cWrapperName: "casadi__GenericType__isBool"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isBool(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isBool()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isBool(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isBool(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isBool();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isCallback" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isCallback"
-// cWrapperName: "casadi__GenericType__isCallback"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isCallback(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isCallback()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isCallback(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isCallback(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isCallback();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isDerivativeGenerator" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isDerivativeGenerator"
-// cWrapperName: "casadi__GenericType__isDerivativeGenerator"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isDerivativeGenerator(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isDerivativeGenerator()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isDerivativeGenerator(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isDerivativeGenerator(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isDerivativeGenerator();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isDict" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isDict"
-// cWrapperName: "casadi__GenericType__isDict"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isDict(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isDict()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isDict(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isDict(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isDict();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isDouble" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isDouble"
-// cWrapperName: "casadi__GenericType__isDouble"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isDouble(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isDouble()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isDouble(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isDouble(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isDouble();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isDoubleVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isDoubleVector"
-// cWrapperName: "casadi__GenericType__isDoubleVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isDoubleVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isDoubleVector()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isDoubleVector(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isDoubleVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isDoubleVector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isFunction" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isFunction"
-// cWrapperName: "casadi__GenericType__isFunction"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isFunction(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isFunction()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isFunction(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isFunction(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isFunction();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isInt" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isInt"
-// cWrapperName: "casadi__GenericType__isInt"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isInt(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isInt()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isInt(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isInt(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isInt();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isIntVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isIntVector"
-// cWrapperName: "casadi__GenericType__isIntVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isIntVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isIntVector()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isIntVector(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isIntVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isIntVector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isIntVectorVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isIntVectorVector"
-// cWrapperName: "casadi__GenericType__isIntVectorVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isIntVectorVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isIntVectorVector()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isIntVectorVector(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isIntVectorVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isIntVectorVector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isString" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isString"
-// cWrapperName: "casadi__GenericType__isString"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isString(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isString()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isString(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isString(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isString();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isStringVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isStringVector"
-// cWrapperName: "casadi__GenericType__isStringVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isStringVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isStringVector()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isStringVector(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isStringVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isStringVector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isVoidPointer" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isVoidPointer"
-// cWrapperName: "casadi__GenericType__isVoidPointer"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isVoidPointer(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isVoidPointer()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isVoidPointer(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isVoidPointer(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isVoidPointer();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isemptyVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::isemptyVector"
-// cWrapperName: "casadi__GenericType__isemptyVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__isemptyVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->isemptyVector()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__isemptyVector(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__isemptyVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->isemptyVector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator !=" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::operator !="
-// cWrapperName: "casadi__GenericType__operator_nequals"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__operator_nequals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
-// call: "obj->operator !=(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType")))]
-extern "C"
-int
-    casadi__GenericType__operator_nequals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0);
-int
-    casadi__GenericType__operator_nequals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0){
-    try {
-        casadi::GenericType& x0_ = Marshaling<casadi::GenericType&,casadi::GenericType*>::marshal(x0);
-
-        bool ret = obj->operator !=(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ==" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::operator =="
-// cWrapperName: "casadi__GenericType__operator_equals"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__operator_equals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
-// call: "obj->operator ==(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType")))]
-extern "C"
-int
-    casadi__GenericType__operator_equals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0);
-int
-    casadi__GenericType__operator_equals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0){
-    try {
-        casadi::GenericType& x0_ = Marshaling<casadi::GenericType&,casadi::GenericType*>::marshal(x0);
-
-        bool ret = obj->operator ==(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toBool" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toBool"
-// cWrapperName: "casadi__GenericType__toBool"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__toBool(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toBool()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__toBool(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__toBool(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        bool ret = obj->toBool();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toDict" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toDict"
-// cWrapperName: "casadi__GenericType__toDict"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))
-// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
-// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__GenericType__toDict(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toDict()"
-// params: []
-extern "C"
-std::map< std::string, casadi::GenericType* >*
-    casadi__GenericType__toDict(std::string ** err_msg, casadi::GenericType* obj);
-std::map< std::string, casadi::GenericType* >*
-    casadi__GenericType__toDict(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        std::map< std::string, casadi::GenericType > ret = obj->toDict();
-        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toDouble" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toDouble"
-// cWrapperName: "casadi__GenericType__toDouble"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__GenericType__toDouble(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toDouble()"
-// params: []
-extern "C"
-double
-    casadi__GenericType__toDouble(std::string ** err_msg, casadi::GenericType* obj);
-double
-    casadi__GenericType__toDouble(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        double ret = obj->toDouble();
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toDoubleVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toDoubleVector"
-// cWrapperName: "casadi__GenericType__toDoubleVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__GenericType__toDoubleVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toDoubleVector()"
-// params: []
-extern "C"
-std::vector< double >*
-    casadi__GenericType__toDoubleVector(std::string ** err_msg, casadi::GenericType* obj);
-std::vector< double >*
-    casadi__GenericType__toDoubleVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        std::vector< double > ret = obj->toDoubleVector();
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toFunction" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toFunction"
-// cWrapperName: "casadi__GenericType__toFunction"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__GenericType__toFunction(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toFunction()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__GenericType__toFunction(std::string ** err_msg, casadi::GenericType* obj);
-casadi::Function*
-    casadi__GenericType__toFunction(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        casadi::Function ret = obj->toFunction();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toInt" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toInt"
-// cWrapperName: "casadi__GenericType__toInt"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__GenericType__toInt(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toInt()"
-// params: []
-extern "C"
-int
-    casadi__GenericType__toInt(std::string ** err_msg, casadi::GenericType* obj);
-int
-    casadi__GenericType__toInt(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        int ret = obj->toInt();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toIntVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toIntVector"
-// cWrapperName: "casadi__GenericType__toIntVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__GenericType__toIntVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toIntVector()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__GenericType__toIntVector(std::string ** err_msg, casadi::GenericType* obj);
-std::vector< int >*
-    casadi__GenericType__toIntVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        std::vector< int > ret = obj->toIntVector();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toIntVectorVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toIntVectorVector"
-// cWrapperName: "casadi__GenericType__toIntVectorVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: StdVec (StdVec CInt)
-// cWrapperRetType: "std::vector< std::vector< int >* >*"
-// proto: "std::vector< std::vector< int >* >*\n    casadi__GenericType__toIntVectorVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toIntVectorVector()"
-// params: []
-extern "C"
-std::vector< std::vector< int >* >*
-    casadi__GenericType__toIntVectorVector(std::string ** err_msg, casadi::GenericType* obj);
-std::vector< std::vector< int >* >*
-    casadi__GenericType__toIntVectorVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        std::vector< std::vector< int > > ret = obj->toIntVectorVector();
-        return WrapReturn< std::vector< std::vector< int >* >*, std::vector< std::vector< int > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toString" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toString"
-// cWrapperName: "casadi__GenericType__toString"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__GenericType__toString(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toString()"
-// params: []
-extern "C"
-std::string*
-    casadi__GenericType__toString(std::string ** err_msg, casadi::GenericType* obj);
-std::string*
-    casadi__GenericType__toString(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        std::string ret = obj->toString();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toStringVector" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toStringVector"
-// cWrapperName: "casadi__GenericType__toStringVector"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: StdVec StdString
-// cWrapperRetType: "std::vector< std::string* >*"
-// proto: "std::vector< std::string* >*\n    casadi__GenericType__toStringVector(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toStringVector()"
-// params: []
-extern "C"
-std::vector< std::string* >*
-    casadi__GenericType__toStringVector(std::string ** err_msg, casadi::GenericType* obj);
-std::vector< std::string* >*
-    casadi__GenericType__toStringVector(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        std::vector< std::string > ret = obj->toStringVector();
-        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toVoidPointer" ===============
-// class: "casadi::GenericType"
-// cppName: "casadi::GenericType::toVoidPointer"
-// cWrapperName: "casadi__GenericType__toVoidPointer"
-// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__GenericType__toVoidPointer(std::string ** err_msg, casadi::GenericType* obj)"
-// call: "obj->toVoidPointer()"
-// params: []
-extern "C"
-void
-    casadi__GenericType__toVoidPointer(std::string ** err_msg, casadi::GenericType* obj);
-void
-    casadi__GenericType__toVoidPointer(std::string ** err_msg, casadi::GenericType* obj){
-    try {
-
-        obj->toVoidPointer();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "HomotopyNlpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "HomotopyNlpSolver")
-extern "C"
-void delete_casadi__HomotopyNlpSolver(casadi::HomotopyNlpSolver* obj);
-void delete_casadi__HomotopyNlpSolver(casadi::HomotopyNlpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::HomotopyNlpSolver"
-// cppName: "casadi::HomotopyNlpSolver"
-// cWrapperName: "casadi__HomotopyNlpSolver__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "HomotopyNlpSolver")
-// cWrapperRetType: "casadi::HomotopyNlpSolver*"
-// proto: "casadi::HomotopyNlpSolver*\n    casadi__HomotopyNlpSolver__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::HomotopyNlpSolver()"
-// params: []
-extern "C"
-casadi::HomotopyNlpSolver*
-    casadi__HomotopyNlpSolver__CONSTRUCTOR(std::string ** err_msg);
-casadi::HomotopyNlpSolver*
-    casadi__HomotopyNlpSolver__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::HomotopyNlpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::HomotopyNlpSolver"
-// cppName: "casadi::HomotopyNlpSolver::doc"
-// cWrapperName: "casadi__HomotopyNlpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__HomotopyNlpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::HomotopyNlpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__HomotopyNlpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__HomotopyNlpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::HomotopyNlpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::HomotopyNlpSolver"
-// cppName: "casadi::HomotopyNlpSolver::hasPlugin"
-// cWrapperName: "casadi__HomotopyNlpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__HomotopyNlpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::HomotopyNlpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__HomotopyNlpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__HomotopyNlpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::HomotopyNlpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::HomotopyNlpSolver"
-// cppName: "casadi::HomotopyNlpSolver::loadPlugin"
-// cWrapperName: "casadi__HomotopyNlpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__HomotopyNlpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::HomotopyNlpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__HomotopyNlpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__HomotopyNlpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::HomotopyNlpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "IMatrix")===============
-// classType: UserType (Namespace ["casadi"]) (Name "IMatrix")
-extern "C"
-void delete_casadi__IMatrix(casadi::IMatrix* obj);
-void delete_casadi__IMatrix(casadi::IMatrix* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix"
-// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__CONSTRUCTOR__0(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
-// call: "casadi::IMatrix(x0_)"
-// params: [Ref (Const (StdVec (StdVec CDouble)))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__0(std::string ** err_msg, std::vector< std::vector< double >* >* x0);
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__0(std::string ** err_msg, std::vector< std::vector< double >* >* x0){
-    try {
-        std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);
-
-        return new casadi::IMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix"
-// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, double x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__CONSTRUCTOR__1(std::string ** err_msg, double x0)"
-// call: "casadi::IMatrix(x0_)"
-// params: [CDouble]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__1(std::string ** err_msg, double x0);
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__1(std::string ** err_msg, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        return new casadi::IMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix"
-// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__CONSTRUCTOR__2(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1)"
-// call: "casadi::IMatrix(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__2(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1);
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__2(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::IMatrix& x1_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x1);
-
-        return new casadi::IMatrix(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix"
-// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__CONSTRUCTOR__3(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::IMatrix(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__3(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__3(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        return new casadi::IMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix"
-// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__CONSTRUCTOR__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::IMatrix(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__4(std::string ** err_msg, int x0, int x1);
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        return new casadi::IMatrix(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix"
-// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::IMatrix* x0)"
-// call: "casadi::IMatrix(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::IMatrix* x0);
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::IMatrix* x0){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-
-        return new casadi::IMatrix(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix"
-// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__CONSTRUCTOR__6(std::string ** err_msg)"
-// call: "casadi::IMatrix()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__6(std::string ** err_msg);
-casadi::IMatrix*
-    casadi__IMatrix__CONSTRUCTOR__6(std::string ** err_msg){
-    try {
-
-        return new casadi::IMatrix();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "T" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::T"
-// cWrapperName: "casadi__IMatrix__T"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__T(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->T()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__T(std::string ** err_msg, casadi::IMatrix* obj);
-casadi::IMatrix*
-    casadi__IMatrix__T(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        casadi::IMatrix ret = obj->T();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "__nonzero__" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::__nonzero__"
-// cWrapperName: "casadi__IMatrix____nonzero__"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix____nonzero__(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->__nonzero__()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix____nonzero__(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix____nonzero__(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->__nonzero__();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "append" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::append"
-// cWrapperName: "casadi__IMatrix__append"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__append(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// call: "obj->append(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__append(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
-void
-    casadi__IMatrix__append(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-
-        obj->append(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "appendColumns" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::appendColumns"
-// cWrapperName: "casadi__IMatrix__appendColumns"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__appendColumns(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// call: "obj->appendColumns(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__appendColumns(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
-void
-    casadi__IMatrix__appendColumns(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-
-        obj->appendColumns(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "binary" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::binary"
-// cWrapperName: "casadi__IMatrix__binary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__binary(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// call: "casadi::IMatrix::binary(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__binary(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
-casadi::IMatrix*
-    casadi__IMatrix__binary(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::IMatrix& x1_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        casadi::IMatrix ret = casadi::IMatrix::binary(x0_, x1_, x2_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "className" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::className"
-// cWrapperName: "casadi__IMatrix__className"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__IMatrix__className(std::string ** err_msg)"
-// call: "casadi::IMatrix::className()"
-// params: []
-extern "C"
-std::string*
-    casadi__IMatrix__className(std::string ** err_msg);
-std::string*
-    casadi__IMatrix__className(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::IMatrix::className();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clear" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::clear"
-// cWrapperName: "casadi__IMatrix__clear"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__clear(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->clear()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__clear(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__clear(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->clear();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "colind" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::colind"
-// cWrapperName: "casadi__IMatrix__colind"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__colind(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->colind(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__IMatrix__colind(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-int
-    casadi__IMatrix__colind(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->colind(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "dimString" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::dimString"
-// cWrapperName: "casadi__IMatrix__dimString"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__IMatrix__dimString(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->dimString()"
-// params: []
-extern "C"
-std::string*
-    casadi__IMatrix__dimString(std::string ** err_msg, casadi::IMatrix* obj);
-std::string*
-    casadi__IMatrix__dimString(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::string ret = obj->dimString();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::enlarge"
-// cWrapperName: "casadi__IMatrix__enlarge__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__enlarge__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__IMatrix__enlarge__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-void
-    casadi__IMatrix__enlarge__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        obj->enlarge(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::enlarge"
-// cWrapperName: "casadi__IMatrix__enlarge__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__enlarge__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_, x4_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__IMatrix__enlarge__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
-void
-    casadi__IMatrix__enlarge__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::erase"
-// cWrapperName: "casadi__IMatrix__erase__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__erase__0(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
-// call: "obj->erase(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__IMatrix__erase__0(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0);
-void
-    casadi__IMatrix__erase__0(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        obj->erase(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::erase"
-// cWrapperName: "casadi__IMatrix__erase__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__erase__1(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__IMatrix__erase__1(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1);
-void
-    casadi__IMatrix__erase__1(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::erase"
-// cWrapperName: "casadi__IMatrix__erase__2"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__erase__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__IMatrix__erase__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__IMatrix__erase__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::erase"
-// cWrapperName: "casadi__IMatrix__erase__3"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__erase__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// call: "obj->erase(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__IMatrix__erase__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
-void
-    casadi__IMatrix__erase__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->erase(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "eye" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::eye"
-// cWrapperName: "casadi__IMatrix__eye"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__eye(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::eye(x0_)"
-// params: [CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__eye(std::string ** err_msg, int x0);
-casadi::IMatrix*
-    casadi__IMatrix__eye(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::eye(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::find"
-// cWrapperName: "casadi__IMatrix__find__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__IMatrix__find__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->find()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__IMatrix__find__0(std::string ** err_msg, casadi::IMatrix* obj);
-std::vector< int >*
-    casadi__IMatrix__find__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->find();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::find"
-// cWrapperName: "casadi__IMatrix__find__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__IMatrix__find__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->find(x0_)"
-// params: [CBool]
-extern "C"
-std::vector< int >*
-    casadi__IMatrix__find__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-std::vector< int >*
-    casadi__IMatrix__find__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        std::vector< int > ret = obj->find(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__get__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__IMatrix__get__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__get__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__IMatrix__get__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__2"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__get__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__IMatrix__get__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__3"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__get__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__IMatrix__get__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__4"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__IMatrix__get__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__IMatrix__get__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__5"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__get__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__IMatrix__get__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__6"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__get__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__IMatrix__get__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::get"
-// cWrapperName: "casadi__IMatrix__get__7"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__get__7(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// call: "obj->get(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__IMatrix__get__7(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0);
-void
-    casadi__IMatrix__get__7(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->get(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getColind" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getColind"
-// cWrapperName: "casadi__IMatrix__getColind"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__IMatrix__getColind(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getColind()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__IMatrix__getColind(std::string ** err_msg, casadi::IMatrix* obj);
-std::vector< int >*
-    casadi__IMatrix__getColind(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->getColind();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getDep"
-// cWrapperName: "casadi__IMatrix__getDep__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__getDep__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getDep()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__getDep__0(std::string ** err_msg, casadi::IMatrix* obj);
-casadi::IMatrix*
-    casadi__IMatrix__getDep__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        casadi::IMatrix ret = obj->getDep();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getDep"
-// cWrapperName: "casadi__IMatrix__getDep__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__getDep__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->getDep(x0_)"
-// params: [CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__getDep__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-casadi::IMatrix*
-    casadi__IMatrix__getDep__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix ret = obj->getDep(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getElementHash" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getElementHash"
-// cWrapperName: "casadi__IMatrix__getElementHash"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__IMatrix__getElementHash(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getElementHash()"
-// params: []
-extern "C"
-size_t
-    casadi__IMatrix__getElementHash(std::string ** err_msg, casadi::IMatrix* obj);
-size_t
-    casadi__IMatrix__getElementHash(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        size_t ret = obj->getElementHash();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getEqualityCheckingDepth" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getEqualityCheckingDepth"
-// cWrapperName: "casadi__IMatrix__getEqualityCheckingDepth"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__getEqualityCheckingDepth(std::string ** err_msg)"
-// call: "casadi::IMatrix::getEqualityCheckingDepth()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__getEqualityCheckingDepth(std::string ** err_msg);
-int
-    casadi__IMatrix__getEqualityCheckingDepth(std::string ** err_msg){
-    try {
-
-        int ret = casadi::IMatrix::getEqualityCheckingDepth();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getIntValue" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getIntValue"
-// cWrapperName: "casadi__IMatrix__getIntValue"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__getIntValue(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getIntValue()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__getIntValue(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__getIntValue(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->getIntValue();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getNZ"
-// cWrapperName: "casadi__IMatrix__getNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__getNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__getNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__IMatrix__getNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getNZ"
-// cWrapperName: "casadi__IMatrix__getNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__getNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__getNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__IMatrix__getNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getNZ"
-// cWrapperName: "casadi__IMatrix__getNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__getNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// call: "obj->getNZ(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__IMatrix__getNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0);
-void
-    casadi__IMatrix__getNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->getNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getName" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getName"
-// cWrapperName: "casadi__IMatrix__getName"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__IMatrix__getName(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getName()"
-// params: []
-extern "C"
-std::string*
-    casadi__IMatrix__getName(std::string ** err_msg, casadi::IMatrix* obj);
-std::string*
-    casadi__IMatrix__getName(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::string ret = obj->getName();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNdeps" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getNdeps"
-// cWrapperName: "casadi__IMatrix__getNdeps"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__getNdeps(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getNdeps()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__getNdeps(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__getNdeps(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->getNdeps();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRow" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getRow"
-// cWrapperName: "casadi__IMatrix__getRow"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__IMatrix__getRow(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getRow()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__IMatrix__getRow(std::string ** err_msg, casadi::IMatrix* obj);
-std::vector< int >*
-    casadi__IMatrix__getRow(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->getRow();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getSparsity" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getSparsity"
-// cWrapperName: "casadi__IMatrix__getSparsity"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__IMatrix__getSparsity(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__IMatrix__getSparsity(std::string ** err_msg, casadi::IMatrix* obj);
-casadi::Sparsity*
-    casadi__IMatrix__getSparsity(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        casadi::Sparsity ret = obj->getSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getSym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getSym"
-// cWrapperName: "casadi__IMatrix__getSym"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__getSym(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// call: "obj->getSym(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__IMatrix__getSym(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0);
-void
-    casadi__IMatrix__getSym(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->getSym(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getValue" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getValue"
-// cWrapperName: "casadi__IMatrix__getValue__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__IMatrix__getValue__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->getValue(x0_)"
-// params: [CInt]
-extern "C"
-double
-    casadi__IMatrix__getValue__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-double
-    casadi__IMatrix__getValue__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        double ret = obj->getValue(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getValue" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getValue"
-// cWrapperName: "casadi__IMatrix__getValue__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__IMatrix__getValue__1(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getValue()"
-// params: []
-extern "C"
-double
-    casadi__IMatrix__getValue__1(std::string ** err_msg, casadi::IMatrix* obj);
-double
-    casadi__IMatrix__getValue__1(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        double ret = obj->getValue();
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasDuplicates" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::hasDuplicates"
-// cWrapperName: "casadi__IMatrix__hasDuplicates"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__hasDuplicates(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->hasDuplicates()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__hasDuplicates(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__hasDuplicates(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->hasDuplicates();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::hasNZ"
-// cWrapperName: "casadi__IMatrix__hasNZ"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__hasNZ(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
-// call: "obj->hasNZ(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-int
-    casadi__IMatrix__hasNZ(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
-int
-    casadi__IMatrix__hasNZ(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        bool ret = obj->hasNZ(x0_, x1_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasNonStructuralZeros" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::hasNonStructuralZeros"
-// cWrapperName: "casadi__IMatrix__hasNonStructuralZeros"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->hasNonStructuralZeros()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->hasNonStructuralZeros();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::inf"
-// cWrapperName: "casadi__IMatrix__inf__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::IMatrix::inf(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::IMatrix*
-    casadi__IMatrix__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::inf(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::inf"
-// cWrapperName: "casadi__IMatrix__inf__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__inf__1(std::string ** err_msg)"
-// call: "casadi::IMatrix::inf()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__inf__1(std::string ** err_msg);
-casadi::IMatrix*
-    casadi__IMatrix__inf__1(std::string ** err_msg){
-    try {
-
-        casadi::IMatrix ret = casadi::IMatrix::inf();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::inf"
-// cWrapperName: "casadi__IMatrix__inf__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__inf__2(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::inf(x0_)"
-// params: [CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__inf__2(std::string ** err_msg, int x0);
-casadi::IMatrix*
-    casadi__IMatrix__inf__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::inf(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::inf"
-// cWrapperName: "casadi__IMatrix__inf__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__inf__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::IMatrix::inf(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__inf__3(std::string ** err_msg, int x0, int x1);
-casadi::IMatrix*
-    casadi__IMatrix__inf__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::inf(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::inf"
-// cWrapperName: "casadi__IMatrix__inf__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::IMatrix::inf(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::IMatrix*
-    casadi__IMatrix__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::inf(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isCommutative" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isCommutative"
-// cWrapperName: "casadi__IMatrix__isCommutative"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isCommutative(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isCommutative()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isCommutative(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isCommutative(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isCommutative();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isConstant" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isConstant"
-// cWrapperName: "casadi__IMatrix__isConstant"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isConstant(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isConstant()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isConstant(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isConstant(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isConstant();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isIdentity" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isIdentity"
-// cWrapperName: "casadi__IMatrix__isIdentity"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isIdentity(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isIdentity()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isIdentity(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isIdentity(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isIdentity();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isInteger" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isInteger"
-// cWrapperName: "casadi__IMatrix__isInteger"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isInteger(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isInteger()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isInteger(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isInteger(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isInteger();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isLeaf" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isLeaf"
-// cWrapperName: "casadi__IMatrix__isLeaf"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isLeaf(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isLeaf()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isLeaf(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isLeaf(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isLeaf();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isMinusOne" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isMinusOne"
-// cWrapperName: "casadi__IMatrix__isMinusOne"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isMinusOne(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isMinusOne()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isMinusOne(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isMinusOne(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isMinusOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isOne" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isOne"
-// cWrapperName: "casadi__IMatrix__isOne"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isOne(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isOne()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isOne(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isOne(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isRegular" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isRegular"
-// cWrapperName: "casadi__IMatrix__isRegular"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isRegular(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isRegular()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isRegular(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isRegular(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isRegular();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSlice" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isSlice"
-// cWrapperName: "casadi__IMatrix__isSlice__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isSlice__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isSlice()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isSlice__0(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isSlice__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isSlice();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSlice" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isSlice"
-// cWrapperName: "casadi__IMatrix__isSlice__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isSlice__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->isSlice(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__IMatrix__isSlice__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-int
-    casadi__IMatrix__isSlice__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isSlice(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSmooth" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isSmooth"
-// cWrapperName: "casadi__IMatrix__isSmooth"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isSmooth(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isSmooth()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isSmooth(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isSmooth(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isSmooth();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSymbolic" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isSymbolic"
-// cWrapperName: "casadi__IMatrix__isSymbolic"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isSymbolic(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isSymbolic()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isSymbolic(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isSymbolic(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isSymbolic();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isValidInput" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isValidInput"
-// cWrapperName: "casadi__IMatrix__isValidInput"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isValidInput(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isValidInput()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isValidInput(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isValidInput(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isValidInput();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isZero" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isZero"
-// cWrapperName: "casadi__IMatrix__isZero"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isZero(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isZero()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isZero(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isZero(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isZero();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "iscolumn" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::iscolumn"
-// cWrapperName: "casadi__IMatrix__iscolumn"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__iscolumn(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->iscolumn()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__iscolumn(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__iscolumn(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->iscolumn();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isdense" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isdense"
-// cWrapperName: "casadi__IMatrix__isdense"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isdense(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isdense()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isdense(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isdense(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isdense();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isempty"
-// cWrapperName: "casadi__IMatrix__isempty__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isempty__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isempty()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isempty__0(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isempty__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isempty();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isempty"
-// cWrapperName: "casadi__IMatrix__isempty__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isempty__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->isempty(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__IMatrix__isempty__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-int
-    casadi__IMatrix__isempty__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isempty(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isrow" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isrow"
-// cWrapperName: "casadi__IMatrix__isrow"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isrow(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isrow()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isrow(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isrow(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isrow();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isscalar"
-// cWrapperName: "casadi__IMatrix__isscalar__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isscalar__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isscalar()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isscalar__0(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isscalar__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isscalar();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isscalar"
-// cWrapperName: "casadi__IMatrix__isscalar__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isscalar__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->isscalar(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__IMatrix__isscalar__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-int
-    casadi__IMatrix__isscalar__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isscalar(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "issquare" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::issquare"
-// cWrapperName: "casadi__IMatrix__issquare"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__issquare(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->issquare()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__issquare(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__issquare(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->issquare();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istril" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::istril"
-// cWrapperName: "casadi__IMatrix__istril"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__istril(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->istril()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__istril(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__istril(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->istril();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istriu" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::istriu"
-// cWrapperName: "casadi__IMatrix__istriu"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__istriu(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->istriu()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__istriu(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__istriu(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->istriu();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isvector" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::isvector"
-// cWrapperName: "casadi__IMatrix__isvector"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__isvector(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->isvector()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__isvector(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__isvector(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        bool ret = obj->isvector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "makeSparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::makeSparse"
-// cWrapperName: "casadi__IMatrix__makeSparse__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__makeSparse__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->makeSparse()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__makeSparse__0(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__makeSparse__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->makeSparse();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "makeSparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::makeSparse"
-// cWrapperName: "casadi__IMatrix__makeSparse__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__makeSparse__1(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// call: "obj->makeSparse(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__IMatrix__makeSparse__1(std::string ** err_msg, casadi::IMatrix* obj, double x0);
-void
-    casadi__IMatrix__makeSparse__1(std::string ** err_msg, casadi::IMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->makeSparse(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "matrix_matrix" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::matrix_matrix"
-// cWrapperName: "casadi__IMatrix__matrix_matrix"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__matrix_matrix(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// call: "casadi::IMatrix::matrix_matrix(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__matrix_matrix(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
-casadi::IMatrix*
-    casadi__IMatrix__matrix_matrix(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::IMatrix& x1_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        casadi::IMatrix ret = casadi::IMatrix::matrix_matrix(x0_, x1_, x2_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "matrix_scalar" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::matrix_scalar"
-// cWrapperName: "casadi__IMatrix__matrix_scalar"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__matrix_scalar(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// call: "casadi::IMatrix::matrix_scalar(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__matrix_scalar(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
-casadi::IMatrix*
-    casadi__IMatrix__matrix_scalar(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::IMatrix& x1_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        casadi::IMatrix ret = casadi::IMatrix::matrix_scalar(x0_, x1_, x2_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nan"
-// cWrapperName: "casadi__IMatrix__nan__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::IMatrix::nan(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::IMatrix*
-    casadi__IMatrix__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::nan(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nan"
-// cWrapperName: "casadi__IMatrix__nan__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__nan__1(std::string ** err_msg)"
-// call: "casadi::IMatrix::nan()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__nan__1(std::string ** err_msg);
-casadi::IMatrix*
-    casadi__IMatrix__nan__1(std::string ** err_msg){
-    try {
-
-        casadi::IMatrix ret = casadi::IMatrix::nan();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nan"
-// cWrapperName: "casadi__IMatrix__nan__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__nan__2(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::nan(x0_)"
-// params: [CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__nan__2(std::string ** err_msg, int x0);
-casadi::IMatrix*
-    casadi__IMatrix__nan__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::nan(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nan"
-// cWrapperName: "casadi__IMatrix__nan__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__nan__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::IMatrix::nan(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__nan__3(std::string ** err_msg, int x0, int x1);
-casadi::IMatrix*
-    casadi__IMatrix__nan__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::nan(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nan"
-// cWrapperName: "casadi__IMatrix__nan__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::IMatrix::nan(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::IMatrix*
-    casadi__IMatrix__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::nan(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nnz" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nnz"
-// cWrapperName: "casadi__IMatrix__nnz"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__nnz(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->nnz()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__nnz(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__nnz(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->nnz();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nonzeros" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nonzeros"
-// cWrapperName: "casadi__IMatrix__nonzeros"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__IMatrix__nonzeros(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->nonzeros()"
-// params: []
-extern "C"
-std::vector< double >*
-    casadi__IMatrix__nonzeros(std::string ** err_msg, casadi::IMatrix* obj);
-std::vector< double >*
-    casadi__IMatrix__nonzeros(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::vector< double > ret = obj->nonzeros();
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nonzeros_int" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::nonzeros_int"
-// cWrapperName: "casadi__IMatrix__nonzeros_int"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__IMatrix__nonzeros_int(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->nonzeros_int()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__IMatrix__nonzeros_int(std::string ** err_msg, casadi::IMatrix* obj);
-std::vector< int >*
-    casadi__IMatrix__nonzeros_int(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::vector< int > ret = obj->nonzeros_int();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::numel"
-// cWrapperName: "casadi__IMatrix__numel__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__numel__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->numel(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__IMatrix__numel__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-int
-    casadi__IMatrix__numel__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->numel(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::numel"
-// cWrapperName: "casadi__IMatrix__numel__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__numel__1(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->numel()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__numel__1(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__numel__1(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->numel();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::ones"
-// cWrapperName: "casadi__IMatrix__ones__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::IMatrix::ones(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::IMatrix*
-    casadi__IMatrix__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::ones(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::ones"
-// cWrapperName: "casadi__IMatrix__ones__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::IMatrix::ones(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::IMatrix*
-    casadi__IMatrix__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::ones(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::ones"
-// cWrapperName: "casadi__IMatrix__ones__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__ones__2(std::string ** err_msg)"
-// call: "casadi::IMatrix::ones()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__ones__2(std::string ** err_msg);
-casadi::IMatrix*
-    casadi__IMatrix__ones__2(std::string ** err_msg){
-    try {
-
-        casadi::IMatrix ret = casadi::IMatrix::ones();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::ones"
-// cWrapperName: "casadi__IMatrix__ones__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__ones__3(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::ones(x0_)"
-// params: [CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__ones__3(std::string ** err_msg, int x0);
-casadi::IMatrix*
-    casadi__IMatrix__ones__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::ones(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::ones"
-// cWrapperName: "casadi__IMatrix__ones__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__ones__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::IMatrix::ones(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__ones__4(std::string ** err_msg, int x0, int x1);
-casadi::IMatrix*
-    casadi__IMatrix__ones__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::ones(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator +" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::operator +"
-// cWrapperName: "casadi__IMatrix__operator_plus"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__operator_plus(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->operator +()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__operator_plus(std::string ** err_msg, casadi::IMatrix* obj);
-casadi::IMatrix*
-    casadi__IMatrix__operator_plus(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        casadi::IMatrix ret = obj->operator +();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator -" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::operator -"
-// cWrapperName: "casadi__IMatrix__operator_minus"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__operator_minus(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->operator -()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__operator_minus(std::string ** err_msg, casadi::IMatrix* obj);
-casadi::IMatrix*
-    casadi__IMatrix__operator_minus(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        casadi::IMatrix ret = obj->operator -();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "printDense" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::printDense"
-// cWrapperName: "casadi__IMatrix__printDense"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__printDense(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->printDense()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__printDense(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__printDense(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->printDense();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printScalar" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::printScalar"
-// cWrapperName: "casadi__IMatrix__printScalar"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__printScalar(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->printScalar()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__printScalar(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__printScalar(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->printScalar();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printSparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::printSparse"
-// cWrapperName: "casadi__IMatrix__printSparse"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__printSparse(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->printSparse()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__printSparse(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__printSparse(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->printSparse();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printSplit" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::printSplit"
-// cWrapperName: "casadi__IMatrix__printSplit"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__printSplit(std::string ** err_msg, casadi::IMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
-// call: "obj->printSplit(x0_, x1_)"
-// params: [Ref (StdVec StdString),Ref (StdVec StdString)]
-extern "C"
-void
-    casadi__IMatrix__printSplit(std::string ** err_msg, casadi::IMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1);
-void
-    casadi__IMatrix__printSplit(std::string ** err_msg, casadi::IMatrix* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1){
-    try {
-        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);
-        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);
-
-        obj->printSplit(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printVector" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::printVector"
-// cWrapperName: "casadi__IMatrix__printVector"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__printVector(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->printVector()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__printVector(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__printVector(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->printVector();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printme" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::printme"
-// cWrapperName: "casadi__IMatrix__printme"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__printme(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// call: "obj->printme(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__printme(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
-casadi::IMatrix*
-    casadi__IMatrix__printme(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-
-        casadi::IMatrix ret = obj->printme(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "remove" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::remove"
-// cWrapperName: "casadi__IMatrix__remove"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__remove(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->remove(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__IMatrix__remove(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__IMatrix__remove(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->remove(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reserve" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::reserve"
-// cWrapperName: "casadi__IMatrix__reserve__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__reserve__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
-// call: "obj->reserve(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__IMatrix__reserve__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
-void
-    casadi__IMatrix__reserve__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->reserve(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reserve" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::reserve"
-// cWrapperName: "casadi__IMatrix__reserve__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__reserve__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->reserve(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__IMatrix__reserve__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-void
-    casadi__IMatrix__reserve__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        obj->reserve(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resetInput" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::resetInput"
-// cWrapperName: "casadi__IMatrix__resetInput"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__resetInput(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->resetInput()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__resetInput(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__resetInput(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->resetInput();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resize" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::resize"
-// cWrapperName: "casadi__IMatrix__resize"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__resize(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
-// call: "obj->resize(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__IMatrix__resize(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
-void
-    casadi__IMatrix__resize(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->resize(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "row" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::row"
-// cWrapperName: "casadi__IMatrix__row"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__row(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->row(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__IMatrix__row(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-int
-    casadi__IMatrix__row(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->row(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sanityCheck"
-// cWrapperName: "casadi__IMatrix__sanityCheck__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__sanityCheck__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->sanityCheck()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__sanityCheck__0(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__sanityCheck__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->sanityCheck();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sanityCheck"
-// cWrapperName: "casadi__IMatrix__sanityCheck__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__sanityCheck__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->sanityCheck(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__IMatrix__sanityCheck__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-void
-    casadi__IMatrix__sanityCheck__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->sanityCheck(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "scalar_matrix" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::scalar_matrix"
-// cWrapperName: "casadi__IMatrix__scalar_matrix"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__scalar_matrix(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
-// call: "casadi::IMatrix::scalar_matrix(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__scalar_matrix(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
-casadi::IMatrix*
-    casadi__IMatrix__scalar_matrix(std::string ** err_msg, int x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::IMatrix& x1_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        casadi::IMatrix ret = casadi::IMatrix::scalar_matrix(x0_, x1_, x2_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__set__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__IMatrix__set__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__set__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__IMatrix__set__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__2"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__set__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__IMatrix__set__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__3"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__set__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__IMatrix__set__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__4"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__IMatrix__set__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__IMatrix__set__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__5"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__set__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__IMatrix__set__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__6"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__set__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__IMatrix__set__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__7"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__7(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// call: "obj->set(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__IMatrix__set__7(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0);
-void
-    casadi__IMatrix__set__7(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__8"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__8(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0, int x1)"
-// call: "obj->set(x0_, x1_)"
-// params: [Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__IMatrix__set__8(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0, int x1);
-void
-    casadi__IMatrix__set__8(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0, int x1){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->set(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__9"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__9(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// call: "obj->set(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__IMatrix__set__9(std::string ** err_msg, casadi::IMatrix* obj, double x0);
-void
-    casadi__IMatrix__set__9(std::string ** err_msg, casadi::IMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::set"
-// cWrapperName: "casadi__IMatrix__set__10"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__set__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
-// call: "obj->set(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__set__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
-void
-    casadi__IMatrix__set__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setEqualityCheckingDepth"
-// cWrapperName: "casadi__IMatrix__setEqualityCheckingDepth__0"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setEqualityCheckingDepth__0(std::string ** err_msg)"
-// call: "casadi::IMatrix::setEqualityCheckingDepth()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__setEqualityCheckingDepth__0(std::string ** err_msg);
-void
-    casadi__IMatrix__setEqualityCheckingDepth__0(std::string ** err_msg){
-    try {
-
-        casadi::IMatrix::setEqualityCheckingDepth();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setEqualityCheckingDepth"
-// cWrapperName: "casadi__IMatrix__setEqualityCheckingDepth__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::setEqualityCheckingDepth(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__IMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
-void
-    casadi__IMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix::setEqualityCheckingDepth(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setNZ"
-// cWrapperName: "casadi__IMatrix__setNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__IMatrix__setNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__IMatrix__setNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setNZ"
-// cWrapperName: "casadi__IMatrix__setNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__IMatrix__setNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2);
-void
-    casadi__IMatrix__setNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setNZ"
-// cWrapperName: "casadi__IMatrix__setNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// call: "obj->setNZ(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__IMatrix__setNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0);
-void
-    casadi__IMatrix__setNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->setNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setNZ"
-// cWrapperName: "casadi__IMatrix__setNZ__3"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setNZ__3(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// call: "obj->setNZ(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__IMatrix__setNZ__3(std::string ** err_msg, casadi::IMatrix* obj, double x0);
-void
-    casadi__IMatrix__setNZ__3(std::string ** err_msg, casadi::IMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->setNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setPrecision" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setPrecision"
-// cWrapperName: "casadi__IMatrix__setPrecision"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setPrecision(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::setPrecision(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__IMatrix__setPrecision(std::string ** err_msg, int x0);
-void
-    casadi__IMatrix__setPrecision(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix::setPrecision(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setScientific" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setScientific"
-// cWrapperName: "casadi__IMatrix__setScientific"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setScientific(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::setScientific(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__IMatrix__setScientific(std::string ** err_msg, int x0);
-void
-    casadi__IMatrix__setScientific(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::IMatrix::setScientific(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setSym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setSym"
-// cWrapperName: "casadi__IMatrix__setSym"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setSym(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0)"
-// call: "obj->setSym(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__IMatrix__setSym(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0);
-void
-    casadi__IMatrix__setSym(std::string ** err_msg, casadi::IMatrix* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->setSym(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setValue" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setValue"
-// cWrapperName: "casadi__IMatrix__setValue__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, double x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setValue__0(std::string ** err_msg, casadi::IMatrix* obj, double x0, int x1)"
-// call: "obj->setValue(x0_, x1_)"
-// params: [CDouble,CInt]
-extern "C"
-void
-    casadi__IMatrix__setValue__0(std::string ** err_msg, casadi::IMatrix* obj, double x0, int x1);
-void
-    casadi__IMatrix__setValue__0(std::string ** err_msg, casadi::IMatrix* obj, double x0, int x1){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setValue(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setValue" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setValue"
-// cWrapperName: "casadi__IMatrix__setValue__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setValue__1(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
-// call: "obj->setValue(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__IMatrix__setValue__1(std::string ** err_msg, casadi::IMatrix* obj, double x0);
-void
-    casadi__IMatrix__setValue__1(std::string ** err_msg, casadi::IMatrix* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->setValue(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setWidth" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setWidth"
-// cWrapperName: "casadi__IMatrix__setWidth"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setWidth(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::setWidth(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__IMatrix__setWidth(std::string ** err_msg, int x0);
-void
-    casadi__IMatrix__setWidth(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix::setWidth(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setZero" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::setZero"
-// cWrapperName: "casadi__IMatrix__setZero"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IMatrix__setZero(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->setZero()"
-// params: []
-extern "C"
-void
-    casadi__IMatrix__setZero(std::string ** err_msg, casadi::IMatrix* obj);
-void
-    casadi__IMatrix__setZero(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        obj->setZero();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::shape"
-// cWrapperName: "casadi__IMatrix__shape__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__shape__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->shape(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__IMatrix__shape__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-int
-    casadi__IMatrix__shape__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->shape(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::shape"
-// cWrapperName: "casadi__IMatrix__shape__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__IMatrix__shape__1(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->shape()"
-// params: []
-extern "C"
-std::pair< int, int >*
-    casadi__IMatrix__shape__1(std::string ** err_msg, casadi::IMatrix* obj);
-std::pair< int, int >*
-    casadi__IMatrix__shape__1(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::pair< int, int > ret = obj->shape();
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::size"
-// cWrapperName: "casadi__IMatrix__size"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__size(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->size()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__size(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__size(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->size();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size1" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::size1"
-// cWrapperName: "casadi__IMatrix__size1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__size1(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->size1()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__size1(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__size1(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->size1();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size2" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::size2"
-// cWrapperName: "casadi__IMatrix__size2"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__size2(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->size2()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__size2(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__size2(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->size2();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeD" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sizeD"
-// cWrapperName: "casadi__IMatrix__sizeD"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__sizeD(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->sizeD()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__sizeD(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__sizeD(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->sizeD();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeL" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sizeL"
-// cWrapperName: "casadi__IMatrix__sizeL"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__sizeL(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->sizeL()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__sizeL(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__sizeL(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->sizeL();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeU" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sizeU"
-// cWrapperName: "casadi__IMatrix__sizeU"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IMatrix__sizeU(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->sizeU()"
-// params: []
-extern "C"
-int
-    casadi__IMatrix__sizeU(std::string ** err_msg, casadi::IMatrix* obj);
-int
-    casadi__IMatrix__sizeU(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        int ret = obj->sizeU();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sparse"
-// cWrapperName: "casadi__IMatrix__sparse__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1)"
-// call: "casadi::IMatrix::sparse(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1);
-casadi::IMatrix*
-    casadi__IMatrix__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::IMatrix* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::IMatrix& x1_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::sparse(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sparse"
-// cWrapperName: "casadi__IMatrix__sparse__1"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sparse__1(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::IMatrix::sparse(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sparse__1(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::IMatrix*
-    casadi__IMatrix__sparse__1(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::sparse(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sparse"
-// cWrapperName: "casadi__IMatrix__sparse__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sparse__2(std::string ** err_msg)"
-// call: "casadi::IMatrix::sparse()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sparse__2(std::string ** err_msg);
-casadi::IMatrix*
-    casadi__IMatrix__sparse__2(std::string ** err_msg){
-    try {
-
-        casadi::IMatrix ret = casadi::IMatrix::sparse();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sparse"
-// cWrapperName: "casadi__IMatrix__sparse__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sparse__3(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::sparse(x0_)"
-// params: [CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sparse__3(std::string ** err_msg, int x0);
-casadi::IMatrix*
-    casadi__IMatrix__sparse__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::sparse(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sparse"
-// cWrapperName: "casadi__IMatrix__sparse__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sparse__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::IMatrix::sparse(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sparse__4(std::string ** err_msg, int x0, int x1);
-casadi::IMatrix*
-    casadi__IMatrix__sparse__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::sparse(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sparsity" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sparsity"
-// cWrapperName: "casadi__IMatrix__sparsity"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__IMatrix__sparsity(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->sparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__IMatrix__sparsity(std::string ** err_msg, casadi::IMatrix* obj);
-casadi::Sparsity*
-    casadi__IMatrix__sparsity(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        casadi::Sparsity ret = obj->sparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
-// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
-// proto: "std::vector< std::vector< casadi::IMatrix* >* >*\n    casadi__IMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// call: "casadi::IMatrix::sym(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::IMatrix* >* >*
-    casadi__IMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
-std::vector< std::vector< casadi::IMatrix* >* >*
-    casadi__IMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        std::vector< std::vector< casadi::IMatrix > > ret = casadi::IMatrix::sym(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< std::vector< std::vector< casadi::IMatrix* >* >*, std::vector< std::vector< casadi::IMatrix > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
-// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
-// proto: "std::vector< std::vector< casadi::IMatrix* >* >*\n    casadi__IMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// call: "casadi::IMatrix::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::IMatrix* >* >*
-    casadi__IMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
-std::vector< std::vector< casadi::IMatrix* >* >*
-    casadi__IMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< std::vector< casadi::IMatrix > > ret = casadi::IMatrix::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< std::vector< casadi::IMatrix* >* >*, std::vector< std::vector< casadi::IMatrix > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
-// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
-// proto: "std::vector< casadi::IMatrix* >*\n    casadi__IMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// call: "casadi::IMatrix::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt]
-extern "C"
-std::vector< casadi::IMatrix* >*
-    casadi__IMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
-std::vector< casadi::IMatrix* >*
-    casadi__IMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< casadi::IMatrix > ret = casadi::IMatrix::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
-// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
-// proto: "std::vector< casadi::IMatrix* >*\n    casadi__IMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// call: "casadi::IMatrix::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
-extern "C"
-std::vector< casadi::IMatrix* >*
-    casadi__IMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
-std::vector< casadi::IMatrix* >*
-    casadi__IMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        std::vector< casadi::IMatrix > ret = casadi::IMatrix::sym(x0_, x1_, x2_);
-        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// call: "casadi::IMatrix::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
-casadi::IMatrix*
-    casadi__IMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::sym(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// call: "casadi::IMatrix::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
-casadi::IMatrix*
-    casadi__IMatrix__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::sym(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sym__6(std::string ** err_msg, std::string* x0)"
-// call: "casadi::IMatrix::sym(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sym__6(std::string ** err_msg, std::string* x0);
-casadi::IMatrix*
-    casadi__IMatrix__sym__6(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::sym(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sym__7(std::string ** err_msg, std::string* x0, int x1)"
-// call: "casadi::IMatrix::sym(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sym__7(std::string ** err_msg, std::string* x0, int x1);
-casadi::IMatrix*
-    casadi__IMatrix__sym__7(std::string ** err_msg, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::sym(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::sym"
-// cWrapperName: "casadi__IMatrix__sym__8"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// call: "casadi::IMatrix::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
-casadi::IMatrix*
-    casadi__IMatrix__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        casadi::IMatrix ret = casadi::IMatrix::sym(x0_, x1_, x2_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toSlice" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::toSlice"
-// cWrapperName: "casadi__IMatrix__toSlice__0"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__IMatrix__toSlice__0(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->toSlice()"
-// params: []
-extern "C"
-casadi::Slice*
-    casadi__IMatrix__toSlice__0(std::string ** err_msg, casadi::IMatrix* obj);
-casadi::Slice*
-    casadi__IMatrix__toSlice__0(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        casadi::Slice ret = obj->toSlice();
-        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toSlice" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::toSlice"
-// cWrapperName: "casadi__IMatrix__toSlice__1"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__IMatrix__toSlice__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
-// call: "obj->toSlice(x0_)"
-// params: [CBool]
-extern "C"
-casadi::Slice*
-    casadi__IMatrix__toSlice__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
-casadi::Slice*
-    casadi__IMatrix__toSlice__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::Slice ret = obj->toSlice(x0_);
-        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::triplet"
-// cWrapperName: "casadi__IMatrix__triplet__0"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, std::pair< int, int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, std::pair< int, int >* x3)"
-// call: "casadi::IMatrix::triplet(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, std::pair< int, int >* x3);
-casadi::IMatrix*
-    casadi__IMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, std::pair< int, int >* x3){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        std::pair< int, int > x3_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x3);
-
-        casadi::IMatrix ret = casadi::IMatrix::triplet(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::triplet"
-// cWrapperName: "casadi__IMatrix__triplet__1"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, int x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, int x3, int x4)"
-// call: "casadi::IMatrix::triplet(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, int x3, int x4);
-casadi::IMatrix*
-    casadi__IMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2, int x3, int x4){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        casadi::IMatrix ret = casadi::IMatrix::triplet(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::triplet"
-// cWrapperName: "casadi__IMatrix__triplet__2"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
-// call: "casadi::IMatrix::triplet(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2);
-casadi::IMatrix*
-    casadi__IMatrix__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IMatrix* x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        casadi::IMatrix ret = casadi::IMatrix::triplet(x0_, x1_, x2_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "unary" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::unary"
-// cWrapperName: "casadi__IMatrix__unary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::IMatrix* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__unary(std::string ** err_msg, int x0, casadi::IMatrix* x1)"
-// call: "casadi::IMatrix::unary(x0_, x1_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__unary(std::string ** err_msg, int x0, casadi::IMatrix* x1);
-casadi::IMatrix*
-    casadi__IMatrix__unary(std::string ** err_msg, int x0, casadi::IMatrix* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::IMatrix& x1_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::unary(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::zeros"
-// cWrapperName: "casadi__IMatrix__zeros__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::IMatrix::zeros(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::IMatrix*
-    casadi__IMatrix__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::zeros(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::zeros"
-// cWrapperName: "casadi__IMatrix__zeros__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::IMatrix::zeros(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::IMatrix*
-    casadi__IMatrix__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::zeros(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::zeros"
-// cWrapperName: "casadi__IMatrix__zeros__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__zeros__2(std::string ** err_msg)"
-// call: "casadi::IMatrix::zeros()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__zeros__2(std::string ** err_msg);
-casadi::IMatrix*
-    casadi__IMatrix__zeros__2(std::string ** err_msg){
-    try {
-
-        casadi::IMatrix ret = casadi::IMatrix::zeros();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::zeros"
-// cWrapperName: "casadi__IMatrix__zeros__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__zeros__3(std::string ** err_msg, int x0)"
-// call: "casadi::IMatrix::zeros(x0_)"
-// params: [CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__zeros__3(std::string ** err_msg, int x0);
-casadi::IMatrix*
-    casadi__IMatrix__zeros__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::IMatrix ret = casadi::IMatrix::zeros(x0_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::zeros"
-// cWrapperName: "casadi__IMatrix__zeros__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__IMatrix__zeros__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::IMatrix::zeros(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::IMatrix*
-    casadi__IMatrix__zeros__4(std::string ** err_msg, int x0, int x1);
-casadi::IMatrix*
-    casadi__IMatrix__zeros__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::IMatrix ret = casadi::IMatrix::zeros(x0_, x1_);
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getRepresentation"
-// cWrapperName: "casadi__IMatrix__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__IMatrix__getRepresentation(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__IMatrix__getRepresentation(std::string ** err_msg, casadi::IMatrix* obj);
-std::string*
-    casadi__IMatrix__getRepresentation(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::IMatrix"
-// cppName: "casadi::IMatrix::getDescription"
-// cWrapperName: "casadi__IMatrix__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__IMatrix__getDescription(std::string ** err_msg, casadi::IMatrix* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__IMatrix__getDescription(std::string ** err_msg, casadi::IMatrix* obj);
-std::string*
-    casadi__IMatrix__getDescription(std::string ** err_msg, casadi::IMatrix* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "ImplicitFunction")===============
-// classType: UserType (Namespace ["casadi"]) (Name "ImplicitFunction")
-extern "C"
-void delete_casadi__ImplicitFunction(casadi::ImplicitFunction* obj);
-void delete_casadi__ImplicitFunction(casadi::ImplicitFunction* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction"
-// cWrapperName: "casadi__ImplicitFunction__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ImplicitFunction")
-// cWrapperRetType: "casadi::ImplicitFunction*"
-// proto: "casadi::ImplicitFunction*\n    casadi__ImplicitFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2)"
-// call: "casadi::ImplicitFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::ImplicitFunction*
-    casadi__ImplicitFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2);
-casadi::ImplicitFunction*
-    casadi__ImplicitFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-
-        return new casadi::ImplicitFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction"
-// cWrapperName: "casadi__ImplicitFunction__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "ImplicitFunction")
-// cWrapperRetType: "casadi::ImplicitFunction*"
-// proto: "casadi::ImplicitFunction*\n    casadi__ImplicitFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::ImplicitFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::ImplicitFunction*
-    casadi__ImplicitFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::ImplicitFunction*
-    casadi__ImplicitFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::ImplicitFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction"
-// cWrapperName: "casadi__ImplicitFunction__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "ImplicitFunction")
-// cWrapperRetType: "casadi::ImplicitFunction*"
-// proto: "casadi::ImplicitFunction*\n    casadi__ImplicitFunction__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::ImplicitFunction()"
-// params: []
-extern "C"
-casadi::ImplicitFunction*
-    casadi__ImplicitFunction__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::ImplicitFunction*
-    casadi__ImplicitFunction__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::ImplicitFunction();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction::doc"
-// cWrapperName: "casadi__ImplicitFunction__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__ImplicitFunction__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::ImplicitFunction::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__ImplicitFunction__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__ImplicitFunction__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::ImplicitFunction::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getF" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction::getF"
-// cWrapperName: "casadi__ImplicitFunction__getF"
-// protoArgs: "(std::string ** err_msg, casadi::ImplicitFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__ImplicitFunction__getF(std::string ** err_msg, casadi::ImplicitFunction* obj)"
-// call: "obj->getF()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__ImplicitFunction__getF(std::string ** err_msg, casadi::ImplicitFunction* obj);
-casadi::Function*
-    casadi__ImplicitFunction__getF(std::string ** err_msg, casadi::ImplicitFunction* obj){
-    try {
-
-        casadi::Function ret = obj->getF();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getJac" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction::getJac"
-// cWrapperName: "casadi__ImplicitFunction__getJac"
-// protoArgs: "(std::string ** err_msg, casadi::ImplicitFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__ImplicitFunction__getJac(std::string ** err_msg, casadi::ImplicitFunction* obj)"
-// call: "obj->getJac()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__ImplicitFunction__getJac(std::string ** err_msg, casadi::ImplicitFunction* obj);
-casadi::Function*
-    casadi__ImplicitFunction__getJac(std::string ** err_msg, casadi::ImplicitFunction* obj){
-    try {
-
-        casadi::Function ret = obj->getJac();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getLinsol" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction::getLinsol"
-// cWrapperName: "casadi__ImplicitFunction__getLinsol"
-// protoArgs: "(std::string ** err_msg, casadi::ImplicitFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
-// cWrapperRetType: "casadi::LinearSolver*"
-// proto: "casadi::LinearSolver*\n    casadi__ImplicitFunction__getLinsol(std::string ** err_msg, casadi::ImplicitFunction* obj)"
-// call: "obj->getLinsol()"
-// params: []
-extern "C"
-casadi::LinearSolver*
-    casadi__ImplicitFunction__getLinsol(std::string ** err_msg, casadi::ImplicitFunction* obj);
-casadi::LinearSolver*
-    casadi__ImplicitFunction__getLinsol(std::string ** err_msg, casadi::ImplicitFunction* obj){
-    try {
-
-        casadi::LinearSolver ret = obj->getLinsol();
-        return WrapReturn< casadi::LinearSolver*, casadi::LinearSolver >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction::hasPlugin"
-// cWrapperName: "casadi__ImplicitFunction__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__ImplicitFunction__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::ImplicitFunction::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__ImplicitFunction__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__ImplicitFunction__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::ImplicitFunction::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::ImplicitFunction"
-// cppName: "casadi::ImplicitFunction::loadPlugin"
-// cWrapperName: "casadi__ImplicitFunction__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__ImplicitFunction__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::ImplicitFunction::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__ImplicitFunction__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__ImplicitFunction__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::ImplicitFunction::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Integrator")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Integrator")
-extern "C"
-void delete_casadi__Integrator(casadi::Integrator* obj);
-void delete_casadi__Integrator(casadi::Integrator* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2)"
-// call: "casadi::Integrator(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::MX > x2_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x2);
-
-        return new casadi::Integrator(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::Integrator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::MX > x2_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::Integrator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2)"
-// call: "casadi::Integrator(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::SX > x2_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x2);
-
-        return new casadi::Integrator(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::Integrator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::SX > x2_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::Integrator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2)"
-// call: "casadi::Integrator(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdPair (UserType (Namespace ["casadi"]) (Name "Function")) (UserType (Namespace ["casadi"]) (Name "Function"))))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::pair< casadi::Function, casadi::Function > x2_ = Marshaling<std::pair< casadi::Function, casadi::Function >,std::pair< casadi::Function*, casadi::Function* >*>::marshal(x2);
-
-        return new casadi::Integrator(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::Integrator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdPair (UserType (Namespace ["casadi"]) (Name "Function")) (UserType (Namespace ["casadi"]) (Name "Function")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, std::pair< casadi::Function*, casadi::Function* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::pair< casadi::Function, casadi::Function > x2_ = Marshaling<std::pair< casadi::Function, casadi::Function >,std::pair< casadi::Function*, casadi::Function* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::Integrator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2)"
-// call: "casadi::Integrator(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-
-        return new casadi::Integrator(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::Integrator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::Integrator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator"
-// cWrapperName: "casadi__Integrator__CONSTRUCTOR__8"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__CONSTRUCTOR__8(std::string ** err_msg)"
-// call: "casadi::Integrator()"
-// params: []
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__8(std::string ** err_msg);
-casadi::Integrator*
-    casadi__Integrator__CONSTRUCTOR__8(std::string ** err_msg){
-    try {
-
-        return new casadi::Integrator();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clone" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::clone"
-// cWrapperName: "casadi__Integrator__clone"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
-// cWrapperRetType: "casadi::Integrator*"
-// proto: "casadi::Integrator*\n    casadi__Integrator__clone(std::string ** err_msg, casadi::Integrator* obj)"
-// call: "obj->clone()"
-// params: []
-extern "C"
-casadi::Integrator*
-    casadi__Integrator__clone(std::string ** err_msg, casadi::Integrator* obj);
-casadi::Integrator*
-    casadi__Integrator__clone(std::string ** err_msg, casadi::Integrator* obj){
-    try {
-
-        casadi::Integrator ret = obj->clone();
-        return WrapReturn< casadi::Integrator*, casadi::Integrator >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::doc"
-// cWrapperName: "casadi__Integrator__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Integrator__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Integrator::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__Integrator__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__Integrator__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::Integrator::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAugmented" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::getAugmented"
-// cWrapperName: "casadi__Integrator__getAugmented"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdPair (UserType (Namespace ["casadi"]) (Name "Function")) (UserType (Namespace ["casadi"]) (Name "Function"))
-// cWrapperRetType: "std::pair< casadi::Function*, casadi::Function* >*"
-// proto: "std::pair< casadi::Function*, casadi::Function* >*\n    casadi__Integrator__getAugmented(std::string ** err_msg, casadi::Integrator* obj, int x0, int x1)"
-// call: "obj->getAugmented(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-std::pair< casadi::Function*, casadi::Function* >*
-    casadi__Integrator__getAugmented(std::string ** err_msg, casadi::Integrator* obj, int x0, int x1);
-std::pair< casadi::Function*, casadi::Function* >*
-    casadi__Integrator__getAugmented(std::string ** err_msg, casadi::Integrator* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        std::pair< casadi::Function, casadi::Function > ret = obj->getAugmented(x0_, x1_);
-        return WrapReturn< std::pair< casadi::Function*, casadi::Function* >*, std::pair< casadi::Function, casadi::Function > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDAE" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::getDAE"
-// cWrapperName: "casadi__Integrator__getDAE"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__Integrator__getDAE(std::string ** err_msg, casadi::Integrator* obj)"
-// call: "obj->getDAE()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__Integrator__getDAE(std::string ** err_msg, casadi::Integrator* obj);
-casadi::Function*
-    casadi__Integrator__getDAE(std::string ** err_msg, casadi::Integrator* obj){
-    try {
-
-        casadi::Function ret = obj->getDAE();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::hasPlugin"
-// cWrapperName: "casadi__Integrator__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Integrator__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Integrator::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__Integrator__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__Integrator__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::Integrator::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "integrate" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::integrate"
-// cWrapperName: "casadi__Integrator__integrate"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Integrator__integrate(std::string ** err_msg, casadi::Integrator* obj, double x0)"
-// call: "obj->integrate(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__Integrator__integrate(std::string ** err_msg, casadi::Integrator* obj, double x0);
-void
-    casadi__Integrator__integrate(std::string ** err_msg, casadi::Integrator* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->integrate(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "integrateB" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::integrateB"
-// cWrapperName: "casadi__Integrator__integrateB"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Integrator__integrateB(std::string ** err_msg, casadi::Integrator* obj, double x0)"
-// call: "obj->integrateB(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__Integrator__integrateB(std::string ** err_msg, casadi::Integrator* obj, double x0);
-void
-    casadi__Integrator__integrateB(std::string ** err_msg, casadi::Integrator* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->integrateB(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::loadPlugin"
-// cWrapperName: "casadi__Integrator__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Integrator__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Integrator::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__Integrator__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__Integrator__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::Integrator::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printStats" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::printStats"
-// cWrapperName: "casadi__Integrator__printStats"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Integrator__printStats(std::string ** err_msg, casadi::Integrator* obj)"
-// call: "obj->printStats()"
-// params: []
-extern "C"
-void
-    casadi__Integrator__printStats(std::string ** err_msg, casadi::Integrator* obj);
-void
-    casadi__Integrator__printStats(std::string ** err_msg, casadi::Integrator* obj){
-    try {
-
-        obj->printStats();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reset" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::reset"
-// cWrapperName: "casadi__Integrator__reset"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Integrator__reset(std::string ** err_msg, casadi::Integrator* obj)"
-// call: "obj->reset()"
-// params: []
-extern "C"
-void
-    casadi__Integrator__reset(std::string ** err_msg, casadi::Integrator* obj);
-void
-    casadi__Integrator__reset(std::string ** err_msg, casadi::Integrator* obj){
-    try {
-
-        obj->reset();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resetB" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::resetB"
-// cWrapperName: "casadi__Integrator__resetB"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Integrator__resetB(std::string ** err_msg, casadi::Integrator* obj)"
-// call: "obj->resetB()"
-// params: []
-extern "C"
-void
-    casadi__Integrator__resetB(std::string ** err_msg, casadi::Integrator* obj);
-void
-    casadi__Integrator__resetB(std::string ** err_msg, casadi::Integrator* obj){
-    try {
-
-        obj->resetB();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setStopTime" ===============
-// class: "casadi::Integrator"
-// cppName: "casadi::Integrator::setStopTime"
-// cWrapperName: "casadi__Integrator__setStopTime"
-// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Integrator__setStopTime(std::string ** err_msg, casadi::Integrator* obj, double x0)"
-// call: "obj->setStopTime(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__Integrator__setStopTime(std::string ** err_msg, casadi::Integrator* obj, double x0);
-void
-    casadi__Integrator__setStopTime(std::string ** err_msg, casadi::Integrator* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->setStopTime(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "IterationCallback")===============
-// classType: UserType (Namespace ["casadi"]) (Name "IterationCallback")
-extern "C"
-void delete_casadi__IterationCallback(casadi::IterationCallback* obj);
-void delete_casadi__IterationCallback(casadi::IterationCallback* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::IterationCallback"
-// cppName: "casadi::IterationCallback"
-// cWrapperName: "casadi__IterationCallback__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IterationCallback")
-// cWrapperRetType: "casadi::IterationCallback*"
-// proto: "casadi::IterationCallback*\n    casadi__IterationCallback__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::IterationCallback()"
-// params: []
-extern "C"
-casadi::IterationCallback*
-    casadi__IterationCallback__CONSTRUCTOR(std::string ** err_msg);
-casadi::IterationCallback*
-    casadi__IterationCallback__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::IterationCallback();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ()" ===============
-// class: "casadi::IterationCallback"
-// cppName: "casadi::IterationCallback::operator ()"
-// cWrapperName: "casadi__IterationCallback__operator_call"
-// protoArgs: "(std::string ** err_msg, casadi::IterationCallback* obj, casadi::Function* x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__IterationCallback__operator_call(std::string ** err_msg, casadi::IterationCallback* obj, casadi::Function* x0)"
-// call: "obj->operator ()(x0_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function"))]
-extern "C"
-int
-    casadi__IterationCallback__operator_call(std::string ** err_msg, casadi::IterationCallback* obj, casadi::Function* x0);
-int
-    casadi__IterationCallback__operator_call(std::string ** err_msg, casadi::IterationCallback* obj, casadi::Function* x0){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-
-        int ret = obj->operator ()(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "KernelSum2D")===============
-// classType: UserType (Namespace ["casadi"]) (Name "KernelSum2D")
-extern "C"
-void delete_casadi__KernelSum2D(casadi::KernelSum2D* obj);
-void delete_casadi__KernelSum2D(casadi::KernelSum2D* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::KernelSum2D"
-// cppName: "casadi::KernelSum2D"
-// cWrapperName: "casadi__KernelSum2D__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "KernelSum2D")
-// cWrapperRetType: "casadi::KernelSum2D*"
-// proto: "casadi::KernelSum2D*\n    casadi__KernelSum2D__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4)"
-// call: "casadi::KernelSum2D(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdPair CInt CInt)),CDouble,CInt]
-extern "C"
-casadi::KernelSum2D*
-    casadi__KernelSum2D__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4);
-casadi::KernelSum2D*
-    casadi__KernelSum2D__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        std::pair< int, int > x2_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x2);
-        double x3_ = Marshaling<double,double>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        return new casadi::KernelSum2D(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::KernelSum2D"
-// cppName: "casadi::KernelSum2D"
-// cWrapperName: "casadi__KernelSum2D__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4, std::map< std::string, casadi::GenericType* >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "KernelSum2D")
-// cWrapperRetType: "casadi::KernelSum2D*"
-// proto: "casadi::KernelSum2D*\n    casadi__KernelSum2D__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4, std::map< std::string, casadi::GenericType* >* x5)"
-// call: "casadi::KernelSum2D(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdPair CInt CInt)),CDouble,CInt,Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::KernelSum2D*
-    casadi__KernelSum2D__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4, std::map< std::string, casadi::GenericType* >* x5);
-casadi::KernelSum2D*
-    casadi__KernelSum2D__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, std::pair< int, int >* x2, double x3, int x4, std::map< std::string, casadi::GenericType* >* x5){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        std::pair< int, int > x2_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x2);
-        double x3_ = Marshaling<double,double>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-        std::map< std::string, casadi::GenericType > x5_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x5);
-
-        return new casadi::KernelSum2D(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::KernelSum2D"
-// cppName: "casadi::KernelSum2D"
-// cWrapperName: "casadi__KernelSum2D__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "KernelSum2D")
-// cWrapperRetType: "casadi::KernelSum2D*"
-// proto: "casadi::KernelSum2D*\n    casadi__KernelSum2D__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::KernelSum2D()"
-// params: []
-extern "C"
-casadi::KernelSum2D*
-    casadi__KernelSum2D__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::KernelSum2D*
-    casadi__KernelSum2D__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::KernelSum2D();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "LinearSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "LinearSolver")
-extern "C"
-void delete_casadi__LinearSolver(casadi::LinearSolver* obj);
-void delete_casadi__LinearSolver(casadi::LinearSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver"
-// cWrapperName: "casadi__LinearSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
-// cWrapperRetType: "casadi::LinearSolver*"
-// proto: "casadi::LinearSolver*\n    casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3)"
-// call: "casadi::LinearSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
-extern "C"
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3);
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        return new casadi::LinearSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver"
-// cWrapperName: "casadi__LinearSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3, std::map< std::string, casadi::GenericType* >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
-// cWrapperRetType: "casadi::LinearSolver*"
-// proto: "casadi::LinearSolver*\n    casadi__LinearSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3, std::map< std::string, casadi::GenericType* >* x4)"
-// call: "casadi::LinearSolver(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3, std::map< std::string, casadi::GenericType* >* x4);
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, int x3, std::map< std::string, casadi::GenericType* >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
-
-        return new casadi::LinearSolver(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver"
-// cWrapperName: "casadi__LinearSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
-// cWrapperRetType: "casadi::LinearSolver*"
-// proto: "casadi::LinearSolver*\n    casadi__LinearSolver__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2)"
-// call: "casadi::LinearSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2);
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        return new casadi::LinearSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver"
-// cWrapperName: "casadi__LinearSolver__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
-// cWrapperRetType: "casadi::LinearSolver*"
-// proto: "casadi::LinearSolver*\n    casadi__LinearSolver__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::LinearSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::LinearSolver*
-    casadi__LinearSolver__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Sparsity* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::LinearSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::doc"
-// cWrapperName: "casadi__LinearSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__LinearSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LinearSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__LinearSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__LinearSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::LinearSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getFactorization" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::getFactorization"
-// cWrapperName: "casadi__LinearSolver__getFactorization__0"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__LinearSolver__getFactorization__0(std::string ** err_msg, casadi::LinearSolver* obj)"
-// call: "obj->getFactorization()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__LinearSolver__getFactorization__0(std::string ** err_msg, casadi::LinearSolver* obj);
-casadi::DMatrix*
-    casadi__LinearSolver__getFactorization__0(std::string ** err_msg, casadi::LinearSolver* obj){
-    try {
-
-        casadi::DMatrix ret = obj->getFactorization();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getFactorization" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::getFactorization"
-// cWrapperName: "casadi__LinearSolver__getFactorization__1"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__LinearSolver__getFactorization__1(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
-// call: "obj->getFactorization(x0_)"
-// params: [CBool]
-extern "C"
-casadi::DMatrix*
-    casadi__LinearSolver__getFactorization__1(std::string ** err_msg, casadi::LinearSolver* obj, int x0);
-casadi::DMatrix*
-    casadi__LinearSolver__getFactorization__1(std::string ** err_msg, casadi::LinearSolver* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::DMatrix ret = obj->getFactorization(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getFactorizationSparsity" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::getFactorizationSparsity"
-// cWrapperName: "casadi__LinearSolver__getFactorizationSparsity__0"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__LinearSolver__getFactorizationSparsity__0(std::string ** err_msg, casadi::LinearSolver* obj)"
-// call: "obj->getFactorizationSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__LinearSolver__getFactorizationSparsity__0(std::string ** err_msg, casadi::LinearSolver* obj);
-casadi::Sparsity*
-    casadi__LinearSolver__getFactorizationSparsity__0(std::string ** err_msg, casadi::LinearSolver* obj){
-    try {
-
-        casadi::Sparsity ret = obj->getFactorizationSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getFactorizationSparsity" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::getFactorizationSparsity"
-// cWrapperName: "casadi__LinearSolver__getFactorizationSparsity__1"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__LinearSolver__getFactorizationSparsity__1(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
-// call: "obj->getFactorizationSparsity(x0_)"
-// params: [CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__LinearSolver__getFactorizationSparsity__1(std::string ** err_msg, casadi::LinearSolver* obj, int x0);
-casadi::Sparsity*
-    casadi__LinearSolver__getFactorizationSparsity__1(std::string ** err_msg, casadi::LinearSolver* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->getFactorizationSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::hasPlugin"
-// cWrapperName: "casadi__LinearSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__LinearSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LinearSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__LinearSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__LinearSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::LinearSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::loadPlugin"
-// cWrapperName: "casadi__LinearSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LinearSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LinearSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__LinearSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__LinearSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::LinearSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "prepare" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::prepare"
-// cWrapperName: "casadi__LinearSolver__prepare"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LinearSolver__prepare(std::string ** err_msg, casadi::LinearSolver* obj)"
-// call: "obj->prepare()"
-// params: []
-extern "C"
-void
-    casadi__LinearSolver__prepare(std::string ** err_msg, casadi::LinearSolver* obj);
-void
-    casadi__LinearSolver__prepare(std::string ** err_msg, casadi::LinearSolver* obj){
-    try {
-
-        obj->prepare();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "prepared" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::prepared"
-// cWrapperName: "casadi__LinearSolver__prepared"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__LinearSolver__prepared(std::string ** err_msg, casadi::LinearSolver* obj)"
-// call: "obj->prepared()"
-// params: []
-extern "C"
-int
-    casadi__LinearSolver__prepared(std::string ** err_msg, casadi::LinearSolver* obj);
-int
-    casadi__LinearSolver__prepared(std::string ** err_msg, casadi::LinearSolver* obj){
-    try {
-
-        bool ret = obj->prepared();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "solve" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::solve"
-// cWrapperName: "casadi__LinearSolver__solve__0"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__LinearSolver__solve__0(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1)"
-// call: "obj->solve(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__LinearSolver__solve__0(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1);
-casadi::MX*
-    casadi__LinearSolver__solve__0(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
-
-        casadi::MX ret = obj->solve(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "solve" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::solve"
-// cWrapperName: "casadi__LinearSolver__solve__1"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__LinearSolver__solve__1(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1, int x2)"
-// call: "obj->solve(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
-extern "C"
-casadi::MX*
-    casadi__LinearSolver__solve__1(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1, int x2);
-casadi::MX*
-    casadi__LinearSolver__solve__1(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1, int x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::MX ret = obj->solve(x0_, x1_, x2_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "solve" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::solve"
-// cWrapperName: "casadi__LinearSolver__solve__2"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LinearSolver__solve__2(std::string ** err_msg, casadi::LinearSolver* obj)"
-// call: "obj->solve()"
-// params: []
-extern "C"
-void
-    casadi__LinearSolver__solve__2(std::string ** err_msg, casadi::LinearSolver* obj);
-void
-    casadi__LinearSolver__solve__2(std::string ** err_msg, casadi::LinearSolver* obj){
-    try {
-
-        obj->solve();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "solve" ===============
-// class: "casadi::LinearSolver"
-// cppName: "casadi::LinearSolver::solve"
-// cWrapperName: "casadi__LinearSolver__solve__3"
-// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LinearSolver__solve__3(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
-// call: "obj->solve(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__LinearSolver__solve__3(std::string ** err_msg, casadi::LinearSolver* obj, int x0);
-void
-    casadi__LinearSolver__solve__3(std::string ** err_msg, casadi::LinearSolver* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->solve(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "LpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "LpSolver")
-extern "C"
-void delete_casadi__LpSolver(casadi::LpSolver* obj);
-void delete_casadi__LpSolver(casadi::LpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LpSolver"
-// cppName: "casadi::LpSolver"
-// cWrapperName: "casadi__LpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LpSolver")
-// cWrapperRetType: "casadi::LpSolver*"
-// proto: "casadi::LpSolver*\n    casadi__LpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::LpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::LpSolver*
-    casadi__LpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::LpSolver*
-    casadi__LpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::LpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LpSolver"
-// cppName: "casadi::LpSolver"
-// cWrapperName: "casadi__LpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LpSolver")
-// cWrapperRetType: "casadi::LpSolver*"
-// proto: "casadi::LpSolver*\n    casadi__LpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::LpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::LpSolver*
-    casadi__LpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::LpSolver*
-    casadi__LpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::LpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LpSolver"
-// cppName: "casadi::LpSolver"
-// cWrapperName: "casadi__LpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "LpSolver")
-// cWrapperRetType: "casadi::LpSolver*"
-// proto: "casadi::LpSolver*\n    casadi__LpSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::LpSolver()"
-// params: []
-extern "C"
-casadi::LpSolver*
-    casadi__LpSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::LpSolver*
-    casadi__LpSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::LpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::LpSolver"
-// cppName: "casadi::LpSolver::doc"
-// cWrapperName: "casadi__LpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__LpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__LpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__LpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::LpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::LpSolver"
-// cppName: "casadi::LpSolver::hasPlugin"
-// cWrapperName: "casadi__LpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__LpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__LpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__LpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::LpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::LpSolver"
-// cppName: "casadi::LpSolver::loadPlugin"
-// cWrapperName: "casadi__LpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__LpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__LpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::LpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "LrDleSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "LrDleSolver")
-extern "C"
-void delete_casadi__LrDleSolver(casadi::LrDleSolver* obj);
-void delete_casadi__LrDleSolver(casadi::LrDleSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver"
-// cWrapperName: "casadi__LrDleSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDleSolver")
-// cWrapperRetType: "casadi::LrDleSolver*"
-// proto: "casadi::LrDleSolver*\n    casadi__LrDleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::LrDleSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::LrDleSolver*
-    casadi__LrDleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::LrDleSolver*
-    casadi__LrDleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::LrDleSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver"
-// cWrapperName: "casadi__LrDleSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDleSolver")
-// cWrapperRetType: "casadi::LrDleSolver*"
-// proto: "casadi::LrDleSolver*\n    casadi__LrDleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::LrDleSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::LrDleSolver*
-    casadi__LrDleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::LrDleSolver*
-    casadi__LrDleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::LrDleSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver"
-// cWrapperName: "casadi__LrDleSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDleSolver")
-// cWrapperRetType: "casadi::LrDleSolver*"
-// proto: "casadi::LrDleSolver*\n    casadi__LrDleSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::LrDleSolver()"
-// params: []
-extern "C"
-casadi::LrDleSolver*
-    casadi__LrDleSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::LrDleSolver*
-    casadi__LrDleSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::LrDleSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clone" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver::clone"
-// cWrapperName: "casadi__LrDleSolver__clone"
-// protoArgs: "(std::string ** err_msg, casadi::LrDleSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDleSolver")
-// cWrapperRetType: "casadi::LrDleSolver*"
-// proto: "casadi::LrDleSolver*\n    casadi__LrDleSolver__clone(std::string ** err_msg, casadi::LrDleSolver* obj)"
-// call: "obj->clone()"
-// params: []
-extern "C"
-casadi::LrDleSolver*
-    casadi__LrDleSolver__clone(std::string ** err_msg, casadi::LrDleSolver* obj);
-casadi::LrDleSolver*
-    casadi__LrDleSolver__clone(std::string ** err_msg, casadi::LrDleSolver* obj){
-    try {
-
-        casadi::LrDleSolver ret = obj->clone();
-        return WrapReturn< casadi::LrDleSolver*, casadi::LrDleSolver >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver::doc"
-// cWrapperName: "casadi__LrDleSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__LrDleSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LrDleSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__LrDleSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__LrDleSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::LrDleSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getSparsity" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver::getSparsity"
-// cWrapperName: "casadi__LrDleSolver__getSparsity__0"
-// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__LrDleSolver__getSparsity__0(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0)"
-// call: "casadi::LrDleSolver::getSparsity(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::Sparsity*
-    casadi__LrDleSolver__getSparsity__0(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0);
-casadi::Sparsity*
-    casadi__LrDleSolver__getSparsity__0(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0){
-    try {
-        std::map< std::string, casadi::Sparsity > x0_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::LrDleSolver::getSparsity(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getSparsity" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver::getSparsity"
-// cWrapperName: "casadi__LrDleSolver__getSparsity__1"
-// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__LrDleSolver__getSparsity__1(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0, std::vector< int >* x1)"
-// call: "casadi::LrDleSolver::getSparsity(x0_, x1_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdVec CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__LrDleSolver__getSparsity__1(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0, std::vector< int >* x1);
-casadi::Sparsity*
-    casadi__LrDleSolver__getSparsity__1(std::string ** err_msg, std::map< std::string, casadi::Sparsity* >* x0, std::vector< int >* x1){
-    try {
-        std::map< std::string, casadi::Sparsity > x0_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        casadi::Sparsity ret = casadi::LrDleSolver::getSparsity(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver::hasPlugin"
-// cWrapperName: "casadi__LrDleSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__LrDleSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LrDleSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__LrDleSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__LrDleSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::LrDleSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver::loadPlugin"
-// cWrapperName: "casadi__LrDleSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LrDleSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LrDleSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__LrDleSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__LrDleSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::LrDleSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printStats" ===============
-// class: "casadi::LrDleSolver"
-// cppName: "casadi::LrDleSolver::printStats"
-// cWrapperName: "casadi__LrDleSolver__printStats"
-// protoArgs: "(std::string ** err_msg, casadi::LrDleSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LrDleSolver__printStats(std::string ** err_msg, casadi::LrDleSolver* obj)"
-// call: "obj->printStats()"
-// params: []
-extern "C"
-void
-    casadi__LrDleSolver__printStats(std::string ** err_msg, casadi::LrDleSolver* obj);
-void
-    casadi__LrDleSolver__printStats(std::string ** err_msg, casadi::LrDleSolver* obj){
-    try {
-
-        obj->printStats();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "LrDpleSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "LrDpleSolver")
-extern "C"
-void delete_casadi__LrDpleSolver(casadi::LrDpleSolver* obj);
-void delete_casadi__LrDpleSolver(casadi::LrDpleSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver"
-// cWrapperName: "casadi__LrDpleSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDpleSolver")
-// cWrapperRetType: "casadi::LrDpleSolver*"
-// proto: "casadi::LrDpleSolver*\n    casadi__LrDpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2)"
-// call: "casadi::LrDpleSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))))]
-extern "C"
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2);
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, std::vector< casadi::Sparsity > > x2_ = Marshaling<std::map< std::string, std::vector< casadi::Sparsity > >,std::map< std::string, std::vector< casadi::Sparsity* >* >*>::marshal(x2);
-
-        return new casadi::LrDpleSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver"
-// cWrapperName: "casadi__LrDpleSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDpleSolver")
-// cWrapperRetType: "casadi::LrDpleSolver*"
-// proto: "casadi::LrDpleSolver*\n    casadi__LrDpleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::LrDpleSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, std::vector< casadi::Sparsity* >* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, std::vector< casadi::Sparsity > > x2_ = Marshaling<std::map< std::string, std::vector< casadi::Sparsity > >,std::map< std::string, std::vector< casadi::Sparsity* >* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::LrDpleSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver"
-// cWrapperName: "casadi__LrDpleSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDpleSolver")
-// cWrapperRetType: "casadi::LrDpleSolver*"
-// proto: "casadi::LrDpleSolver*\n    casadi__LrDpleSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::LrDpleSolver()"
-// params: []
-extern "C"
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::LrDpleSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clone" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver::clone"
-// cWrapperName: "casadi__LrDpleSolver__clone"
-// protoArgs: "(std::string ** err_msg, casadi::LrDpleSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "LrDpleSolver")
-// cWrapperRetType: "casadi::LrDpleSolver*"
-// proto: "casadi::LrDpleSolver*\n    casadi__LrDpleSolver__clone(std::string ** err_msg, casadi::LrDpleSolver* obj)"
-// call: "obj->clone()"
-// params: []
-extern "C"
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__clone(std::string ** err_msg, casadi::LrDpleSolver* obj);
-casadi::LrDpleSolver*
-    casadi__LrDpleSolver__clone(std::string ** err_msg, casadi::LrDpleSolver* obj){
-    try {
-
-        casadi::LrDpleSolver ret = obj->clone();
-        return WrapReturn< casadi::LrDpleSolver*, casadi::LrDpleSolver >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver::doc"
-// cWrapperName: "casadi__LrDpleSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__LrDpleSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LrDpleSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__LrDpleSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__LrDpleSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::LrDpleSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver::hasPlugin"
-// cWrapperName: "casadi__LrDpleSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__LrDpleSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LrDpleSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__LrDpleSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__LrDpleSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::LrDpleSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver::loadPlugin"
-// cWrapperName: "casadi__LrDpleSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LrDpleSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::LrDpleSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__LrDpleSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__LrDpleSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::LrDpleSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printStats" ===============
-// class: "casadi::LrDpleSolver"
-// cppName: "casadi::LrDpleSolver::printStats"
-// cWrapperName: "casadi__LrDpleSolver__printStats"
-// protoArgs: "(std::string ** err_msg, casadi::LrDpleSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__LrDpleSolver__printStats(std::string ** err_msg, casadi::LrDpleSolver* obj)"
-// call: "obj->printStats()"
-// params: []
-extern "C"
-void
-    casadi__LrDpleSolver__printStats(std::string ** err_msg, casadi::LrDpleSolver* obj);
-void
-    casadi__LrDpleSolver__printStats(std::string ** err_msg, casadi::LrDpleSolver* obj){
-    try {
-
-        obj->printStats();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "MX")===============
-// classType: UserType (Namespace ["casadi"]) (Name "MX")
-extern "C"
-void delete_casadi__MX(casadi::MX* obj);
-void delete_casadi__MX(casadi::MX* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DMatrix* x0)"
-// call: "casadi::MX(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DMatrix* x0);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        return new casadi::MX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0)"
-// call: "casadi::MX(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        return new casadi::MX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0)"
-// call: "casadi::MX(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        return new casadi::MX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, double x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0)"
-// call: "casadi::MX(x0_)"
-// params: [CDouble]
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        return new casadi::MX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
-// call: "casadi::MX(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
-
-        return new casadi::MX(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::MX(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        return new casadi::MX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::MX(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        return new casadi::MX(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX"
-// cWrapperName: "casadi__MX__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__7(std::string ** err_msg)"
-// call: "casadi::MX()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__7(std::string ** err_msg);
-casadi::MX*
-    casadi__MX__CONSTRUCTOR__7(std::string ** err_msg){
-    try {
-
-        return new casadi::MX();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "T" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::T"
-// cWrapperName: "casadi__MX__T"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__T(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->T()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__T(std::string ** err_msg, casadi::MX* obj);
-casadi::MX*
-    casadi__MX__T(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::MX ret = obj->T();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "__nonzero__" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::__nonzero__"
-// cWrapperName: "casadi__MX____nonzero__"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->__nonzero__()"
-// params: []
-extern "C"
-int
-    casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->__nonzero__();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "append" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::append"
-// cWrapperName: "casadi__MX__append"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__append(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// call: "obj->append(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__MX__append(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
-void
-    casadi__MX__append(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->append(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "appendColumns" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::appendColumns"
-// cWrapperName: "casadi__MX__appendColumns"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__appendColumns(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// call: "obj->appendColumns(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__MX__appendColumns(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
-void
-    casadi__MX__appendColumns(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->appendColumns(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "attachAssert" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::attachAssert"
-// cWrapperName: "casadi__MX__attachAssert__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// call: "obj->attachAssert(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
-casadi::MX*
-    casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        casadi::MX ret = obj->attachAssert(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "attachAssert" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::attachAssert"
-// cWrapperName: "casadi__MX__attachAssert__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1)"
-// call: "obj->attachAssert(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1);
-casadi::MX*
-    casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->attachAssert(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "binary" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::binary"
-// cWrapperName: "casadi__MX__binary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2)"
-// call: "casadi::MX::binary(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2);
-casadi::MX*
-    casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
-        casadi::MX& x2_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x2);
-
-        casadi::MX ret = casadi::MX::binary(x0_, x1_, x2_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "colind" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::colind"
-// cWrapperName: "casadi__MX__colind"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__colind(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->colind(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__MX__colind(std::string ** err_msg, casadi::MX* obj, int x0);
-int
-    casadi__MX__colind(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->colind(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "dimString" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::dimString"
-// cWrapperName: "casadi__MX__dimString"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__MX__dimString(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->dimString()"
-// params: []
-extern "C"
-std::string*
-    casadi__MX__dimString(std::string ** err_msg, casadi::MX* obj);
-std::string*
-    casadi__MX__dimString(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        std::string ret = obj->dimString();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::enlarge"
-// cWrapperName: "casadi__MX__enlarge__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__enlarge__0(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__MX__enlarge__0(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-void
-    casadi__MX__enlarge__0(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        obj->enlarge(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::enlarge"
-// cWrapperName: "casadi__MX__enlarge__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__enlarge__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_, x4_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__MX__enlarge__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
-void
-    casadi__MX__enlarge__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::erase"
-// cWrapperName: "casadi__MX__erase__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__erase__0(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0)"
-// call: "obj->erase(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__MX__erase__0(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0);
-void
-    casadi__MX__erase__0(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        obj->erase(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::erase"
-// cWrapperName: "casadi__MX__erase__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__erase__1(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__MX__erase__1(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1);
-void
-    casadi__MX__erase__1(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::erase"
-// cWrapperName: "casadi__MX__erase__2"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__erase__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__MX__erase__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__MX__erase__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::erase"
-// cWrapperName: "casadi__MX__erase__3"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__erase__3(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// call: "obj->erase(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__MX__erase__3(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
-void
-    casadi__MX__erase__3(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->erase(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "eye" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::eye"
-// cWrapperName: "casadi__MX__eye"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__eye(std::string ** err_msg, int x0)"
-// call: "casadi::MX::eye(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__eye(std::string ** err_msg, int x0);
-casadi::MX*
-    casadi__MX__eye(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::eye(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::find"
-// cWrapperName: "casadi__MX__find__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__MX__find__0(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->find()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__MX__find__0(std::string ** err_msg, casadi::MX* obj);
-std::vector< int >*
-    casadi__MX__find__0(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        std::vector< int > ret = obj->find();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::find"
-// cWrapperName: "casadi__MX__find__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__MX__find__1(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->find(x0_)"
-// params: [CBool]
-extern "C"
-std::vector< int >*
-    casadi__MX__find__1(std::string ** err_msg, casadi::MX* obj, int x0);
-std::vector< int >*
-    casadi__MX__find__1(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        std::vector< int > ret = obj->find(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::get"
-// cWrapperName: "casadi__MX__get__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__get__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__get__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__MX__get__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::get"
-// cWrapperName: "casadi__MX__get__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__get__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__get__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__MX__get__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::get"
-// cWrapperName: "casadi__MX__get__2"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__get__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__get__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__MX__get__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::get"
-// cWrapperName: "casadi__MX__get__3"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__get__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__get__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__MX__get__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::get"
-// cWrapperName: "casadi__MX__get__4"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__get__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__MX__get__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__MX__get__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::get"
-// cWrapperName: "casadi__MX__get__5"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__get__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__get__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__MX__get__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::get"
-// cWrapperName: "casadi__MX__get__6"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__get__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__get__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__MX__get__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getColind" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getColind"
-// cWrapperName: "casadi__MX__getColind"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__MX__getColind(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getColind()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__MX__getColind(std::string ** err_msg, casadi::MX* obj);
-std::vector< int >*
-    casadi__MX__getColind(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        std::vector< int > ret = obj->getColind();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getDep"
-// cWrapperName: "casadi__MX__getDep__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__getDep__0(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getDep()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__getDep__0(std::string ** err_msg, casadi::MX* obj);
-casadi::MX*
-    casadi__MX__getDep__0(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::MX ret = obj->getDep();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getDep"
-// cWrapperName: "casadi__MX__getDep__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__getDep__1(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->getDep(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__getDep__1(std::string ** err_msg, casadi::MX* obj, int x0);
-casadi::MX*
-    casadi__MX__getDep__1(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = obj->getDep(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getEqualityCheckingDepth" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getEqualityCheckingDepth"
-// cWrapperName: "casadi__MX__getEqualityCheckingDepth"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__getEqualityCheckingDepth(std::string ** err_msg)"
-// call: "casadi::MX::getEqualityCheckingDepth()"
-// params: []
-extern "C"
-int
-    casadi__MX__getEqualityCheckingDepth(std::string ** err_msg);
-int
-    casadi__MX__getEqualityCheckingDepth(std::string ** err_msg){
-    try {
-
-        int ret = casadi::MX::getEqualityCheckingDepth();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getEvaluationOutput" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getEvaluationOutput"
-// cWrapperName: "casadi__MX__getEvaluationOutput"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__getEvaluationOutput(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getEvaluationOutput()"
-// params: []
-extern "C"
-int
-    casadi__MX__getEvaluationOutput(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__getEvaluationOutput(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->getEvaluationOutput();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getFunction" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getFunction"
-// cWrapperName: "casadi__MX__getFunction__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__MX__getFunction__0(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getFunction()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__MX__getFunction__0(std::string ** err_msg, casadi::MX* obj);
-casadi::Function*
-    casadi__MX__getFunction__0(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::Function ret = obj->getFunction();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getFunction" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getFunction"
-// cWrapperName: "casadi__MX__getFunction__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__MX__getFunction__1(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->getFunction(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Function*
-    casadi__MX__getFunction__1(std::string ** err_msg, casadi::MX* obj, int x0);
-casadi::Function*
-    casadi__MX__getFunction__1(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Function ret = obj->getFunction(x0_);
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getMatrixValue" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getMatrixValue"
-// cWrapperName: "casadi__MX__getMatrixValue"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__MX__getMatrixValue(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getMatrixValue()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__MX__getMatrixValue(std::string ** err_msg, casadi::MX* obj);
-casadi::DMatrix*
-    casadi__MX__getMatrixValue(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::DMatrix ret = obj->getMatrixValue();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getNZ"
-// cWrapperName: "casadi__MX__getNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__getNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__getNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__MX__getNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getNZ"
-// cWrapperName: "casadi__MX__getNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__getNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__getNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__MX__getNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getName" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getName"
-// cWrapperName: "casadi__MX__getName"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__MX__getName(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getName()"
-// params: []
-extern "C"
-std::string*
-    casadi__MX__getName(std::string ** err_msg, casadi::MX* obj);
-std::string*
-    casadi__MX__getName(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        std::string ret = obj->getName();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNdeps" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getNdeps"
-// cWrapperName: "casadi__MX__getNdeps"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__getNdeps(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getNdeps()"
-// params: []
-extern "C"
-int
-    casadi__MX__getNdeps(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__getNdeps(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->getNdeps();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOp" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getOp"
-// cWrapperName: "casadi__MX__getOp"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__getOp(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getOp()"
-// params: []
-extern "C"
-int
-    casadi__MX__getOp(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__getOp(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->getOp();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOutput" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getOutput"
-// cWrapperName: "casadi__MX__getOutput__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getOutput()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj);
-casadi::MX*
-    casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::MX ret = obj->getOutput();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOutput" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getOutput"
-// cWrapperName: "casadi__MX__getOutput__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->getOutput(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0);
-casadi::MX*
-    casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = obj->getOutput(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getPrimitives" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getPrimitives"
-// cWrapperName: "casadi__MX__getPrimitives"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__MX__getPrimitives(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getPrimitives()"
-// params: []
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__MX__getPrimitives(std::string ** err_msg, casadi::MX* obj);
-std::vector< casadi::MX* >*
-    casadi__MX__getPrimitives(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        std::vector< casadi::MX > ret = obj->getPrimitives();
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRow" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getRow"
-// cWrapperName: "casadi__MX__getRow"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__MX__getRow(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getRow()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__MX__getRow(std::string ** err_msg, casadi::MX* obj);
-std::vector< int >*
-    casadi__MX__getRow(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        std::vector< int > ret = obj->getRow();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getSparsity" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getSparsity"
-// cWrapperName: "casadi__MX__getSparsity"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__MX__getSparsity(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__MX__getSparsity(std::string ** err_msg, casadi::MX* obj);
-casadi::Sparsity*
-    casadi__MX__getSparsity(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::Sparsity ret = obj->getSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getTemp" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getTemp"
-// cWrapperName: "casadi__MX__getTemp"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getTemp()"
-// params: []
-extern "C"
-int
-    casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->getTemp();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getValue" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::getValue"
-// cWrapperName: "casadi__MX__getValue"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__MX__getValue(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->getValue()"
-// params: []
-extern "C"
-double
-    casadi__MX__getValue(std::string ** err_msg, casadi::MX* obj);
-double
-    casadi__MX__getValue(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        double ret = obj->getValue();
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasDuplicates" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::hasDuplicates"
-// cWrapperName: "casadi__MX__hasDuplicates"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__hasDuplicates(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->hasDuplicates()"
-// params: []
-extern "C"
-int
-    casadi__MX__hasDuplicates(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__hasDuplicates(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->hasDuplicates();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::inf"
-// cWrapperName: "casadi__MX__inf__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::MX::inf(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::MX*
-    casadi__MX__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::MX*
-    casadi__MX__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::inf(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::inf"
-// cWrapperName: "casadi__MX__inf__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__inf__1(std::string ** err_msg)"
-// call: "casadi::MX::inf()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__inf__1(std::string ** err_msg);
-casadi::MX*
-    casadi__MX__inf__1(std::string ** err_msg){
-    try {
-
-        casadi::MX ret = casadi::MX::inf();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::inf"
-// cWrapperName: "casadi__MX__inf__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__inf__2(std::string ** err_msg, int x0)"
-// call: "casadi::MX::inf(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__inf__2(std::string ** err_msg, int x0);
-casadi::MX*
-    casadi__MX__inf__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::inf(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::inf"
-// cWrapperName: "casadi__MX__inf__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__inf__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::MX::inf(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__inf__3(std::string ** err_msg, int x0, int x1);
-casadi::MX*
-    casadi__MX__inf__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::inf(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::inf"
-// cWrapperName: "casadi__MX__inf__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::MX::inf(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__MX__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::MX*
-    casadi__MX__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::inf(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isBinary" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isBinary"
-// cWrapperName: "casadi__MX__isBinary"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isBinary(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isBinary()"
-// params: []
-extern "C"
-int
-    casadi__MX__isBinary(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isBinary(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isBinary();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isCommutative" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isCommutative"
-// cWrapperName: "casadi__MX__isCommutative"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isCommutative(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isCommutative()"
-// params: []
-extern "C"
-int
-    casadi__MX__isCommutative(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isCommutative(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isCommutative();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isConstant" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isConstant"
-// cWrapperName: "casadi__MX__isConstant"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isConstant(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isConstant()"
-// params: []
-extern "C"
-int
-    casadi__MX__isConstant(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isConstant(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isConstant();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isEvaluation" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isEvaluation"
-// cWrapperName: "casadi__MX__isEvaluation"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isEvaluation(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isEvaluation()"
-// params: []
-extern "C"
-int
-    casadi__MX__isEvaluation(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isEvaluation(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isEvaluation();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isEvaluationOutput" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isEvaluationOutput"
-// cWrapperName: "casadi__MX__isEvaluationOutput"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isEvaluationOutput(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isEvaluationOutput()"
-// params: []
-extern "C"
-int
-    casadi__MX__isEvaluationOutput(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isEvaluationOutput(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isEvaluationOutput();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isIdentity" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isIdentity"
-// cWrapperName: "casadi__MX__isIdentity"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isIdentity(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isIdentity()"
-// params: []
-extern "C"
-int
-    casadi__MX__isIdentity(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isIdentity(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isIdentity();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isMinusOne" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isMinusOne"
-// cWrapperName: "casadi__MX__isMinusOne"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isMinusOne(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isMinusOne()"
-// params: []
-extern "C"
-int
-    casadi__MX__isMinusOne(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isMinusOne(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isMinusOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isMultiplication" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isMultiplication"
-// cWrapperName: "casadi__MX__isMultiplication"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isMultiplication(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isMultiplication()"
-// params: []
-extern "C"
-int
-    casadi__MX__isMultiplication(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isMultiplication(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isMultiplication();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isNorm" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isNorm"
-// cWrapperName: "casadi__MX__isNorm"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isNorm(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isNorm()"
-// params: []
-extern "C"
-int
-    casadi__MX__isNorm(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isNorm(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isNorm();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isOne" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isOne"
-// cWrapperName: "casadi__MX__isOne"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isOne(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isOne()"
-// params: []
-extern "C"
-int
-    casadi__MX__isOne(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isOne(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isOperation" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isOperation"
-// cWrapperName: "casadi__MX__isOperation"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isOperation(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->isOperation(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__MX__isOperation(std::string ** err_msg, casadi::MX* obj, int x0);
-int
-    casadi__MX__isOperation(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        bool ret = obj->isOperation(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isRegular" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isRegular"
-// cWrapperName: "casadi__MX__isRegular"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isRegular(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isRegular()"
-// params: []
-extern "C"
-int
-    casadi__MX__isRegular(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isRegular(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isRegular();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSymbolic" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isSymbolic"
-// cWrapperName: "casadi__MX__isSymbolic"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isSymbolic(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isSymbolic()"
-// params: []
-extern "C"
-int
-    casadi__MX__isSymbolic(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isSymbolic(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isSymbolic();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isTranspose" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isTranspose"
-// cWrapperName: "casadi__MX__isTranspose"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isTranspose(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isTranspose()"
-// params: []
-extern "C"
-int
-    casadi__MX__isTranspose(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isTranspose(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isTranspose();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isUnary" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isUnary"
-// cWrapperName: "casadi__MX__isUnary"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isUnary(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isUnary()"
-// params: []
-extern "C"
-int
-    casadi__MX__isUnary(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isUnary(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isUnary();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isValidInput" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isValidInput"
-// cWrapperName: "casadi__MX__isValidInput"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isValidInput(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isValidInput()"
-// params: []
-extern "C"
-int
-    casadi__MX__isValidInput(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isValidInput(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isValidInput();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isZero" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isZero"
-// cWrapperName: "casadi__MX__isZero"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isZero(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isZero()"
-// params: []
-extern "C"
-int
-    casadi__MX__isZero(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isZero(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isZero();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "iscolumn" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::iscolumn"
-// cWrapperName: "casadi__MX__iscolumn"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__iscolumn(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->iscolumn()"
-// params: []
-extern "C"
-int
-    casadi__MX__iscolumn(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__iscolumn(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->iscolumn();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isdense" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isdense"
-// cWrapperName: "casadi__MX__isdense"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isdense(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isdense()"
-// params: []
-extern "C"
-int
-    casadi__MX__isdense(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isdense(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isdense();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isempty"
-// cWrapperName: "casadi__MX__isempty__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isempty__0(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isempty()"
-// params: []
-extern "C"
-int
-    casadi__MX__isempty__0(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isempty__0(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isempty();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isempty"
-// cWrapperName: "casadi__MX__isempty__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isempty__1(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->isempty(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__MX__isempty__1(std::string ** err_msg, casadi::MX* obj, int x0);
-int
-    casadi__MX__isempty__1(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isempty(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isrow" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isrow"
-// cWrapperName: "casadi__MX__isrow"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isrow(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isrow()"
-// params: []
-extern "C"
-int
-    casadi__MX__isrow(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isrow(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isrow();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isscalar"
-// cWrapperName: "casadi__MX__isscalar__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isscalar__0(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isscalar()"
-// params: []
-extern "C"
-int
-    casadi__MX__isscalar__0(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isscalar__0(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isscalar();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isscalar"
-// cWrapperName: "casadi__MX__isscalar__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isscalar__1(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->isscalar(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__MX__isscalar__1(std::string ** err_msg, casadi::MX* obj, int x0);
-int
-    casadi__MX__isscalar__1(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isscalar(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "issquare" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::issquare"
-// cWrapperName: "casadi__MX__issquare"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__issquare(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->issquare()"
-// params: []
-extern "C"
-int
-    casadi__MX__issquare(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__issquare(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->issquare();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istril" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::istril"
-// cWrapperName: "casadi__MX__istril"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__istril(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->istril()"
-// params: []
-extern "C"
-int
-    casadi__MX__istril(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__istril(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->istril();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istriu" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::istriu"
-// cWrapperName: "casadi__MX__istriu"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__istriu(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->istriu()"
-// params: []
-extern "C"
-int
-    casadi__MX__istriu(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__istriu(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->istriu();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isvector" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::isvector"
-// cWrapperName: "casadi__MX__isvector"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__isvector(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->isvector()"
-// params: []
-extern "C"
-int
-    casadi__MX__isvector(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__isvector(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        bool ret = obj->isvector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "joinPrimitives" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::joinPrimitives"
-// cWrapperName: "casadi__MX__joinPrimitives"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__joinPrimitives(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0)"
-// call: "obj->joinPrimitives(x0_)"
-// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__joinPrimitives(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0);
-casadi::MX*
-    casadi__MX__joinPrimitives(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0){
-    try {
-        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
-
-        casadi::MX ret = obj->joinPrimitives(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "lift" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::lift"
-// cWrapperName: "casadi__MX__lift"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__lift(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// call: "obj->lift(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__MX__lift(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
-void
-    casadi__MX__lift(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->lift(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "makeDense" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::makeDense"
-// cWrapperName: "casadi__MX__makeDense__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__makeDense__0(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->makeDense()"
-// params: []
-extern "C"
-void
-    casadi__MX__makeDense__0(std::string ** err_msg, casadi::MX* obj);
-void
-    casadi__MX__makeDense__0(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        obj->makeDense();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "makeDense" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::makeDense"
-// cWrapperName: "casadi__MX__makeDense__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__makeDense__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// call: "obj->makeDense(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-void
-    casadi__MX__makeDense__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
-void
-    casadi__MX__makeDense__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        obj->makeDense(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "mapping" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::mapping"
-// cWrapperName: "casadi__MX__mapping"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
-// cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix*\n    casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->mapping()"
-// params: []
-extern "C"
-casadi::IMatrix*
-    casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj);
-casadi::IMatrix*
-    casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::IMatrix ret = obj->mapping();
-        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "monitor" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::monitor"
-// cWrapperName: "casadi__MX__monitor"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__monitor(std::string ** err_msg, casadi::MX* obj, std::string* x0)"
-// call: "obj->monitor(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MX__monitor(std::string ** err_msg, casadi::MX* obj, std::string* x0);
-casadi::MX*
-    casadi__MX__monitor(std::string ** err_msg, casadi::MX* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->monitor(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nOut" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::nOut"
-// cWrapperName: "casadi__MX__nOut"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__nOut(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->nOut()"
-// params: []
-extern "C"
-int
-    casadi__MX__nOut(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__nOut(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->nOut();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::nan"
-// cWrapperName: "casadi__MX__nan__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::MX::nan(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::MX*
-    casadi__MX__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::MX*
-    casadi__MX__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::nan(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::nan"
-// cWrapperName: "casadi__MX__nan__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__nan__1(std::string ** err_msg)"
-// call: "casadi::MX::nan()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__nan__1(std::string ** err_msg);
-casadi::MX*
-    casadi__MX__nan__1(std::string ** err_msg){
-    try {
-
-        casadi::MX ret = casadi::MX::nan();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::nan"
-// cWrapperName: "casadi__MX__nan__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__nan__2(std::string ** err_msg, int x0)"
-// call: "casadi::MX::nan(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__nan__2(std::string ** err_msg, int x0);
-casadi::MX*
-    casadi__MX__nan__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::nan(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::nan"
-// cWrapperName: "casadi__MX__nan__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__nan__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::MX::nan(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__nan__3(std::string ** err_msg, int x0, int x1);
-casadi::MX*
-    casadi__MX__nan__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::nan(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::nan"
-// cWrapperName: "casadi__MX__nan__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::MX::nan(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__MX__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::MX*
-    casadi__MX__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::nan(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nnz" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::nnz"
-// cWrapperName: "casadi__MX__nnz"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__nnz(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->nnz()"
-// params: []
-extern "C"
-int
-    casadi__MX__nnz(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__nnz(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->nnz();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numFunctions" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::numFunctions"
-// cWrapperName: "casadi__MX__numFunctions"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__numFunctions(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->numFunctions()"
-// params: []
-extern "C"
-int
-    casadi__MX__numFunctions(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__numFunctions(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->numFunctions();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numPrimitives" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::numPrimitives"
-// cWrapperName: "casadi__MX__numPrimitives"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__numPrimitives(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->numPrimitives()"
-// params: []
-extern "C"
-int
-    casadi__MX__numPrimitives(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__numPrimitives(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->numPrimitives();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::numel"
-// cWrapperName: "casadi__MX__numel__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__numel__0(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->numel(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__MX__numel__0(std::string ** err_msg, casadi::MX* obj, int x0);
-int
-    casadi__MX__numel__0(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->numel(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::numel"
-// cWrapperName: "casadi__MX__numel__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__numel__1(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->numel()"
-// params: []
-extern "C"
-int
-    casadi__MX__numel__1(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__numel__1(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->numel();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::ones"
-// cWrapperName: "casadi__MX__ones__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::MX::ones(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::MX*
-    casadi__MX__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::MX*
-    casadi__MX__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::ones(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::ones"
-// cWrapperName: "casadi__MX__ones__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::MX::ones(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__MX__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::MX*
-    casadi__MX__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::ones(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::ones"
-// cWrapperName: "casadi__MX__ones__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__ones__2(std::string ** err_msg)"
-// call: "casadi::MX::ones()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__ones__2(std::string ** err_msg);
-casadi::MX*
-    casadi__MX__ones__2(std::string ** err_msg){
-    try {
-
-        casadi::MX ret = casadi::MX::ones();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::ones"
-// cWrapperName: "casadi__MX__ones__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__ones__3(std::string ** err_msg, int x0)"
-// call: "casadi::MX::ones(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__ones__3(std::string ** err_msg, int x0);
-casadi::MX*
-    casadi__MX__ones__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::ones(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::ones"
-// cWrapperName: "casadi__MX__ones__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__ones__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::MX::ones(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__ones__4(std::string ** err_msg, int x0, int x1);
-casadi::MX*
-    casadi__MX__ones__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::ones(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator -" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::operator -"
-// cWrapperName: "casadi__MX__operator_minus"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__operator_minus(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->operator -()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__operator_minus(std::string ** err_msg, casadi::MX* obj);
-casadi::MX*
-    casadi__MX__operator_minus(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::MX ret = obj->operator -();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "printme" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::printme"
-// cWrapperName: "casadi__MX__printme"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// call: "obj->printme(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
-casadi::MX*
-    casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        casadi::MX ret = obj->printme(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "resetInput" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::resetInput"
-// cWrapperName: "casadi__MX__resetInput"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__resetInput(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->resetInput()"
-// params: []
-extern "C"
-void
-    casadi__MX__resetInput(std::string ** err_msg, casadi::MX* obj);
-void
-    casadi__MX__resetInput(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        obj->resetInput();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "row" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::row"
-// cWrapperName: "casadi__MX__row"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__row(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->row(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__MX__row(std::string ** err_msg, casadi::MX* obj, int x0);
-int
-    casadi__MX__row(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->row(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::set"
-// cWrapperName: "casadi__MX__set__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__set__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__set__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__MX__set__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::set"
-// cWrapperName: "casadi__MX__set__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__set__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__set__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__MX__set__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::set"
-// cWrapperName: "casadi__MX__set__2"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__set__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__set__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__MX__set__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::set"
-// cWrapperName: "casadi__MX__set__3"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__set__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__set__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__MX__set__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::set"
-// cWrapperName: "casadi__MX__set__4"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__set__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__MX__set__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__MX__set__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::set"
-// cWrapperName: "casadi__MX__set__5"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__set__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__set__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__MX__set__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::set"
-// cWrapperName: "casadi__MX__set__6"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__set__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__set__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__MX__set__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::setEqualityCheckingDepth"
-// cWrapperName: "casadi__MX__setEqualityCheckingDepth__0"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg)"
-// call: "casadi::MX::setEqualityCheckingDepth()"
-// params: []
-extern "C"
-void
-    casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg);
-void
-    casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg){
-    try {
-
-        casadi::MX::setEqualityCheckingDepth();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::setEqualityCheckingDepth"
-// cWrapperName: "casadi__MX__setEqualityCheckingDepth__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
-// call: "casadi::MX::setEqualityCheckingDepth(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
-void
-    casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX::setEqualityCheckingDepth(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::setNZ"
-// cWrapperName: "casadi__MX__setNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__setNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__MX__setNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__MX__setNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::setNZ"
-// cWrapperName: "casadi__MX__setNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__setNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__MX__setNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__MX__setNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setTemp" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::setTemp"
-// cWrapperName: "casadi__MX__setTemp"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->setTemp(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0);
-void
-    casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        obj->setTemp(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::shape"
-// cWrapperName: "casadi__MX__shape__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__shape__0(std::string ** err_msg, casadi::MX* obj, int x0)"
-// call: "obj->shape(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__MX__shape__0(std::string ** err_msg, casadi::MX* obj, int x0);
-int
-    casadi__MX__shape__0(std::string ** err_msg, casadi::MX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->shape(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::shape"
-// cWrapperName: "casadi__MX__shape__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__MX__shape__1(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->shape()"
-// params: []
-extern "C"
-std::pair< int, int >*
-    casadi__MX__shape__1(std::string ** err_msg, casadi::MX* obj);
-std::pair< int, int >*
-    casadi__MX__shape__1(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        std::pair< int, int > ret = obj->shape();
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::size"
-// cWrapperName: "casadi__MX__size"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__size(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->size()"
-// params: []
-extern "C"
-int
-    casadi__MX__size(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__size(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->size();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size1" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::size1"
-// cWrapperName: "casadi__MX__size1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__size1(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->size1()"
-// params: []
-extern "C"
-int
-    casadi__MX__size1(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__size1(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->size1();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size2" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::size2"
-// cWrapperName: "casadi__MX__size2"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__size2(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->size2()"
-// params: []
-extern "C"
-int
-    casadi__MX__size2(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__size2(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->size2();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeD" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sizeD"
-// cWrapperName: "casadi__MX__sizeD"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__sizeD(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->sizeD()"
-// params: []
-extern "C"
-int
-    casadi__MX__sizeD(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__sizeD(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->sizeD();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeL" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sizeL"
-// cWrapperName: "casadi__MX__sizeL"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__sizeL(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->sizeL()"
-// params: []
-extern "C"
-int
-    casadi__MX__sizeL(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__sizeL(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->sizeL();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeU" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sizeU"
-// cWrapperName: "casadi__MX__sizeU"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MX__sizeU(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->sizeU()"
-// params: []
-extern "C"
-int
-    casadi__MX__sizeU(std::string ** err_msg, casadi::MX* obj);
-int
-    casadi__MX__sizeU(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        int ret = obj->sizeU();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sparse"
-// cWrapperName: "casadi__MX__sparse__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
-// call: "casadi::MX::sparse(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1);
-casadi::MX*
-    casadi__MX__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::sparse(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sparse"
-// cWrapperName: "casadi__MX__sparse__1"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sparse__1(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::MX::sparse(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::MX*
-    casadi__MX__sparse__1(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::MX*
-    casadi__MX__sparse__1(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::sparse(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sparse"
-// cWrapperName: "casadi__MX__sparse__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sparse__2(std::string ** err_msg)"
-// call: "casadi::MX::sparse()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__sparse__2(std::string ** err_msg);
-casadi::MX*
-    casadi__MX__sparse__2(std::string ** err_msg){
-    try {
-
-        casadi::MX ret = casadi::MX::sparse();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sparse"
-// cWrapperName: "casadi__MX__sparse__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sparse__3(std::string ** err_msg, int x0)"
-// call: "casadi::MX::sparse(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__sparse__3(std::string ** err_msg, int x0);
-casadi::MX*
-    casadi__MX__sparse__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::sparse(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sparse"
-// cWrapperName: "casadi__MX__sparse__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sparse__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::MX::sparse(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__sparse__4(std::string ** err_msg, int x0, int x1);
-casadi::MX*
-    casadi__MX__sparse__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::sparse(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sparsity" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sparsity"
-// cWrapperName: "casadi__MX__sparsity"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
-// args: "()"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__MX__sparsity(std::string ** err_msg, casadi::MX* obj)"
-// call: "obj->sparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__MX__sparsity(std::string ** err_msg, casadi::MX* obj);
-casadi::Sparsity*
-    casadi__MX__sparsity(std::string ** err_msg, casadi::MX* obj){
-    try {
-
-        casadi::Sparsity ret = obj->sparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "splitPrimitives" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::splitPrimitives"
-// cWrapperName: "casadi__MX__splitPrimitives"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__MX__splitPrimitives(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
-// call: "obj->splitPrimitives(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__MX__splitPrimitives(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
-std::vector< casadi::MX* >*
-    casadi__MX__splitPrimitives(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
-    try {
-        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
-
-        std::vector< casadi::MX > ret = obj->splitPrimitives(x0_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
-// proto: "std::vector< std::vector< casadi::MX* >* >*\n    casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// call: "casadi::MX::sym(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
-// proto: "std::vector< std::vector< casadi::MX* >* >*\n    casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// call: "casadi::MX::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
-std::vector< std::vector< casadi::MX* >* >*
-    casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// call: "casadi::MX::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
-std::vector< casadi::MX* >*
-    casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< casadi::MX > ret = casadi::MX::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// call: "casadi::MX::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
-std::vector< casadi::MX* >*
-    casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        std::vector< casadi::MX > ret = casadi::MX::sym(x0_, x1_, x2_);
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// call: "casadi::MX::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
-casadi::MX*
-    casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::sym(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// call: "casadi::MX::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::MX*
-    casadi__MX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
-casadi::MX*
-    casadi__MX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::sym(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sym__6(std::string ** err_msg, std::string* x0)"
-// call: "casadi::MX::sym(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MX__sym__6(std::string ** err_msg, std::string* x0);
-casadi::MX*
-    casadi__MX__sym__6(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::sym(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1)"
-// call: "casadi::MX::sym(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1);
-casadi::MX*
-    casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::sym(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::sym"
-// cWrapperName: "casadi__MX__sym__8"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// call: "casadi::MX::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
-casadi::MX*
-    casadi__MX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        casadi::MX ret = casadi::MX::sym(x0_, x1_, x2_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "unary" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::unary"
-// cWrapperName: "casadi__MX__unary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::MX* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1)"
-// call: "casadi::MX::unary(x0_, x1_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
-extern "C"
-casadi::MX*
-    casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1);
-casadi::MX*
-    casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::unary(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::zeros"
-// cWrapperName: "casadi__MX__zeros__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::MX::zeros(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::MX*
-    casadi__MX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::MX*
-    casadi__MX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::zeros(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::zeros"
-// cWrapperName: "casadi__MX__zeros__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::MX::zeros(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__MX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::MX*
-    casadi__MX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::zeros(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::zeros"
-// cWrapperName: "casadi__MX__zeros__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__zeros__2(std::string ** err_msg)"
-// call: "casadi::MX::zeros()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MX__zeros__2(std::string ** err_msg);
-casadi::MX*
-    casadi__MX__zeros__2(std::string ** err_msg){
-    try {
-
-        casadi::MX ret = casadi::MX::zeros();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::zeros"
-// cWrapperName: "casadi__MX__zeros__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__zeros__3(std::string ** err_msg, int x0)"
-// call: "casadi::MX::zeros(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__zeros__3(std::string ** err_msg, int x0);
-casadi::MX*
-    casadi__MX__zeros__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = casadi::MX::zeros(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::zeros"
-// cWrapperName: "casadi__MX__zeros__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__zeros__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::MX::zeros(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MX__zeros__4(std::string ** err_msg, int x0, int x1);
-casadi::MX*
-    casadi__MX__zeros__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = casadi::MX::zeros(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "zz_project" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::zz_project"
-// cWrapperName: "casadi__MX__zz_project__0"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__zz_project__0(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
-// call: "obj->zz_project(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::MX*
-    casadi__MX__zz_project__0(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0);
-casadi::MX*
-    casadi__MX__zz_project__0(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::MX ret = obj->zz_project(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "zz_project" ===============
-// class: "casadi::MX"
-// cppName: "casadi::MX::zz_project"
-// cWrapperName: "casadi__MX__zz_project__1"
-// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MX__zz_project__1(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1)"
-// call: "obj->zz_project(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool]
-extern "C"
-casadi::MX*
-    casadi__MX__zz_project__1(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1);
-casadi::MX*
-    casadi__MX__zz_project__1(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        casadi::MX ret = obj->zz_project(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "MXFunction")===============
-// classType: UserType (Namespace ["casadi"]) (Name "MXFunction")
-extern "C"
-void delete_casadi__MXFunction(casadi::MXFunction* obj);
-void delete_casadi__MXFunction(casadi::MXFunction* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2)"
-// call: "casadi::MXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString)))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x2);
-
-        return new casadi::MXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::MXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::MXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2)"
-// call: "casadi::MXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString)))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x2);
-
-        return new casadi::MXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::MXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::MXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2)"
-// call: "casadi::MXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
-
-        return new casadi::MXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::MXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))) (StdVec StdString))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::MX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::MX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::MXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
-// call: "casadi::MXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
-
-        return new casadi::MXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::MXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
-        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::MXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__8(std::string ** err_msg, casadi::Function* x0)"
-// call: "casadi::MXFunction(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__8(std::string ** err_msg, casadi::Function* x0);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__8(std::string ** err_msg, casadi::Function* x0){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-
-        return new casadi::MXFunction(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction"
-// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__9"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
-// cWrapperRetType: "casadi::MXFunction*"
-// proto: "casadi::MXFunction*\n    casadi__MXFunction__CONSTRUCTOR__9(std::string ** err_msg)"
-// call: "casadi::MXFunction()"
-// params: []
-extern "C"
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__9(std::string ** err_msg);
-casadi::MXFunction*
-    casadi__MXFunction__CONSTRUCTOR__9(std::string ** err_msg){
-    try {
-
-        return new casadi::MXFunction();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "countNodes" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::countNodes"
-// cWrapperName: "casadi__MXFunction__countNodes"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__MXFunction__countNodes(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->countNodes()"
-// params: []
-extern "C"
-int
-    casadi__MXFunction__countNodes(std::string ** err_msg, casadi::MXFunction* obj);
-int
-    casadi__MXFunction__countNodes(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        int ret = obj->countNodes();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "expand" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::expand"
-// cWrapperName: "casadi__MXFunction__expand__0"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__MXFunction__expand__0(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->expand()"
-// params: []
-extern "C"
-casadi::SXFunction*
-    casadi__MXFunction__expand__0(std::string ** err_msg, casadi::MXFunction* obj);
-casadi::SXFunction*
-    casadi__MXFunction__expand__0(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        casadi::SXFunction ret = obj->expand();
-        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "expand" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::expand"
-// cWrapperName: "casadi__MXFunction__expand__1"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__MXFunction__expand__1(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0)"
-// call: "obj->expand(x0_)"
-// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-casadi::SXFunction*
-    casadi__MXFunction__expand__1(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0);
-casadi::SXFunction*
-    casadi__MXFunction__expand__1(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0){
-    try {
-        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
-
-        casadi::SXFunction ret = obj->expand(x0_);
-        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "generateLiftingFunctions" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::generateLiftingFunctions"
-// cWrapperName: "casadi__MXFunction__generateLiftingFunctions"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__MXFunction__generateLiftingFunctions(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1)"
-// call: "obj->generateLiftingFunctions(x0_, x1_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "MXFunction")),Ref (UserType (Namespace ["casadi"]) (Name "MXFunction"))]
-extern "C"
-void
-    casadi__MXFunction__generateLiftingFunctions(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1);
-void
-    casadi__MXFunction__generateLiftingFunctions(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1){
-    try {
-        casadi::MXFunction& x0_ = Marshaling<casadi::MXFunction&,casadi::MXFunction*>::marshal(x0);
-        casadi::MXFunction& x1_ = Marshaling<casadi::MXFunction&,casadi::MXFunction*>::marshal(x1);
-
-        obj->generateLiftingFunctions(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getFree" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::getFree"
-// cWrapperName: "casadi__MXFunction__getFree"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__MXFunction__getFree(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->getFree()"
-// params: []
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__MXFunction__getFree(std::string ** err_msg, casadi::MXFunction* obj);
-std::vector< casadi::MX* >*
-    casadi__MXFunction__getFree(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        std::vector< casadi::MX > ret = obj->getFree();
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::grad"
-// cWrapperName: "casadi__MXFunction__grad__0"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__grad__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__grad__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1);
-casadi::MX*
-    casadi__MXFunction__grad__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::grad"
-// cWrapperName: "casadi__MXFunction__grad__1"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__grad__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__grad__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1);
-casadi::MX*
-    casadi__MXFunction__grad__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::grad"
-// cWrapperName: "casadi__MXFunction__grad__2"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__grad__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// call: "obj->grad(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__grad__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
-casadi::MX*
-    casadi__MXFunction__grad__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->grad(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::grad"
-// cWrapperName: "casadi__MXFunction__grad__3"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__grad__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__grad__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__MXFunction__grad__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::grad"
-// cWrapperName: "casadi__MXFunction__grad__4"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__grad__4(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->grad()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MXFunction__grad__4(std::string ** err_msg, casadi::MXFunction* obj);
-casadi::MX*
-    casadi__MXFunction__grad__4(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        casadi::MX ret = obj->grad();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::grad"
-// cWrapperName: "casadi__MXFunction__grad__5"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__grad__5(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// call: "obj->grad(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__grad__5(std::string ** err_msg, casadi::MXFunction* obj, int x0);
-casadi::MX*
-    casadi__MXFunction__grad__5(std::string ** err_msg, casadi::MXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = obj->grad(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::grad"
-// cWrapperName: "casadi__MXFunction__grad__6"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__grad__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__grad__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1);
-casadi::MX*
-    casadi__MXFunction__grad__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputExpr" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::inputExpr"
-// cWrapperName: "casadi__MXFunction__inputExpr__0"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__MXFunction__inputExpr__0(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->inputExpr()"
-// params: []
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__MXFunction__inputExpr__0(std::string ** err_msg, casadi::MXFunction* obj);
-std::vector< casadi::MX* >*
-    casadi__MXFunction__inputExpr__0(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        std::vector< casadi::MX > ret = obj->inputExpr();
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputExpr" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::inputExpr"
-// cWrapperName: "casadi__MXFunction__inputExpr__1"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__inputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// call: "obj->inputExpr(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__inputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
-casadi::MX*
-    casadi__MXFunction__inputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->inputExpr(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputExpr" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::inputExpr"
-// cWrapperName: "casadi__MXFunction__inputExpr__2"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__inputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// call: "obj->inputExpr(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__inputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0);
-casadi::MX*
-    casadi__MXFunction__inputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = obj->inputExpr(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__0"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1);
-casadi::MX*
-    casadi__MXFunction__jac__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__1"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2);
-casadi::MX*
-    casadi__MXFunction__jac__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__2"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3);
-casadi::MX*
-    casadi__MXFunction__jac__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__3"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__3(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__3(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1);
-casadi::MX*
-    casadi__MXFunction__jac__3(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__4"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__4(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const StdString),CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__4(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2);
-casadi::MX*
-    casadi__MXFunction__jac__4(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__5"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__5(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [CInt,Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__5(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3);
-casadi::MX*
-    casadi__MXFunction__jac__5(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__6"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__6(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// call: "obj->jac(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__6(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
-casadi::MX*
-    casadi__MXFunction__jac__6(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->jac(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__7"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__7(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__7(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__MXFunction__jac__7(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__8"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__8(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__8(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2);
-casadi::MX*
-    casadi__MXFunction__jac__8(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__9"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__9(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CBool,CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__9(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3);
-casadi::MX*
-    casadi__MXFunction__jac__9(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__10"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__10(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->jac()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__10(std::string ** err_msg, casadi::MXFunction* obj);
-casadi::MX*
-    casadi__MXFunction__jac__10(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        casadi::MX ret = obj->jac();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__11"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__11(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// call: "obj->jac(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__11(std::string ** err_msg, casadi::MXFunction* obj, int x0);
-casadi::MX*
-    casadi__MXFunction__jac__11(std::string ** err_msg, casadi::MXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = obj->jac(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__12"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__12(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__12(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1);
-casadi::MX*
-    casadi__MXFunction__jac__12(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__13"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__13(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [CInt,CInt,CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__13(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2);
-casadi::MX*
-    casadi__MXFunction__jac__13(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::jac"
-// cWrapperName: "casadi__MXFunction__jac__14"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__jac__14(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,CBool,CBool]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__jac__14(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3);
-casadi::MX*
-    casadi__MXFunction__jac__14(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputExpr" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::outputExpr"
-// cWrapperName: "casadi__MXFunction__outputExpr__0"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
-// cWrapperRetType: "std::vector< casadi::MX* >*"
-// proto: "std::vector< casadi::MX* >*\n    casadi__MXFunction__outputExpr__0(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->outputExpr()"
-// params: []
-extern "C"
-std::vector< casadi::MX* >*
-    casadi__MXFunction__outputExpr__0(std::string ** err_msg, casadi::MXFunction* obj);
-std::vector< casadi::MX* >*
-    casadi__MXFunction__outputExpr__0(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        std::vector< casadi::MX > ret = obj->outputExpr();
-        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputExpr" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::outputExpr"
-// cWrapperName: "casadi__MXFunction__outputExpr__1"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__outputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// call: "obj->outputExpr(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__outputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
-casadi::MX*
-    casadi__MXFunction__outputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->outputExpr(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputExpr" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::outputExpr"
-// cWrapperName: "casadi__MXFunction__outputExpr__2"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__outputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// call: "obj->outputExpr(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__outputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0);
-casadi::MX*
-    casadi__MXFunction__outputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = obj->outputExpr(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::tang"
-// cWrapperName: "casadi__MXFunction__tang__0"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__tang__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__tang__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1);
-casadi::MX*
-    casadi__MXFunction__tang__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::tang"
-// cWrapperName: "casadi__MXFunction__tang__1"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__tang__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__tang__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1);
-casadi::MX*
-    casadi__MXFunction__tang__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::MX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::tang"
-// cWrapperName: "casadi__MXFunction__tang__2"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__tang__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
-// call: "obj->tang(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__tang__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
-casadi::MX*
-    casadi__MXFunction__tang__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::MX ret = obj->tang(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::tang"
-// cWrapperName: "casadi__MXFunction__tang__3"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__tang__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__tang__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1);
-casadi::MX*
-    casadi__MXFunction__tang__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::tang"
-// cWrapperName: "casadi__MXFunction__tang__4"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__tang__4(std::string ** err_msg, casadi::MXFunction* obj)"
-// call: "obj->tang()"
-// params: []
-extern "C"
-casadi::MX*
-    casadi__MXFunction__tang__4(std::string ** err_msg, casadi::MXFunction* obj);
-casadi::MX*
-    casadi__MXFunction__tang__4(std::string ** err_msg, casadi::MXFunction* obj){
-    try {
-
-        casadi::MX ret = obj->tang();
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::tang"
-// cWrapperName: "casadi__MXFunction__tang__5"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__tang__5(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
-// call: "obj->tang(x0_)"
-// params: [CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__tang__5(std::string ** err_msg, casadi::MXFunction* obj, int x0);
-casadi::MX*
-    casadi__MXFunction__tang__5(std::string ** err_msg, casadi::MXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::MX ret = obj->tang(x0_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::MXFunction"
-// cppName: "casadi::MXFunction::tang"
-// cWrapperName: "casadi__MXFunction__tang__6"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MX")
-// cWrapperRetType: "casadi::MX*"
-// proto: "casadi::MX*\n    casadi__MXFunction__tang__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::MX*
-    casadi__MXFunction__tang__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1);
-casadi::MX*
-    casadi__MXFunction__tang__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::MX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Map")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Map")
-extern "C"
-void delete_casadi__Map(casadi::Map* obj);
-void delete_casadi__Map(casadi::Map* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Map"
-// cppName: "casadi::Map"
-// cWrapperName: "casadi__Map__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Map")
-// cWrapperRetType: "casadi::Map*"
-// proto: "casadi::Map*\n    casadi__Map__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4)"
-// call: "casadi::Map(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,Ref (Const (StdVec CBool)),Ref (Const (StdVec CBool))]
-extern "C"
-casadi::Map*
-    casadi__Map__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4);
-casadi::Map*
-    casadi__Map__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        std::vector< bool > x3_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x3);
-        std::vector< bool > x4_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x4);
-
-        return new casadi::Map(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Map"
-// cppName: "casadi::Map"
-// cWrapperName: "casadi__Map__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Map")
-// cWrapperRetType: "casadi::Map*"
-// proto: "casadi::Map*\n    casadi__Map__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5)"
-// call: "casadi::Map(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,Ref (Const (StdVec CBool)),Ref (Const (StdVec CBool)),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Map*
-    casadi__Map__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5);
-casadi::Map*
-    casadi__Map__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        std::vector< bool > x3_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x3);
-        std::vector< bool > x4_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x4);
-        std::map< std::string, casadi::GenericType > x5_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x5);
-
-        return new casadi::Map(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Map"
-// cppName: "casadi::Map"
-// cWrapperName: "casadi__Map__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Map")
-// cWrapperRetType: "casadi::Map*"
-// proto: "casadi::Map*\n    casadi__Map__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::Map()"
-// params: []
-extern "C"
-casadi::Map*
-    casadi__Map__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::Map*
-    casadi__Map__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::Map();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "MapAccum")===============
-// classType: UserType (Namespace ["casadi"]) (Name "MapAccum")
-extern "C"
-void delete_casadi__MapAccum(casadi::MapAccum* obj);
-void delete_casadi__MapAccum(casadi::MapAccum* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MapAccum"
-// cppName: "casadi::MapAccum"
-// cWrapperName: "casadi__MapAccum__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MapAccum")
-// cWrapperRetType: "casadi::MapAccum*"
-// proto: "casadi::MapAccum*\n    casadi__MapAccum__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4)"
-// call: "casadi::MapAccum(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,Ref (Const (StdVec CBool)),Ref (Const (StdVec CInt))]
-extern "C"
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4);
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        std::vector< bool > x3_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-
-        return new casadi::MapAccum(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MapAccum"
-// cppName: "casadi::MapAccum"
-// cWrapperName: "casadi__MapAccum__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MapAccum")
-// cWrapperRetType: "casadi::MapAccum*"
-// proto: "casadi::MapAccum*\n    casadi__MapAccum__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
-// call: "casadi::MapAccum(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,Ref (Const (StdVec CBool)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5);
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        std::vector< bool > x3_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        return new casadi::MapAccum(x0_, x1_, x2_, x3_, x4_, x5_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MapAccum"
-// cppName: "casadi::MapAccum"
-// cWrapperName: "casadi__MapAccum__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5, std::map< std::string, casadi::GenericType* >* x6)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "MapAccum")
-// cWrapperRetType: "casadi::MapAccum*"
-// proto: "casadi::MapAccum*\n    casadi__MapAccum__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5, std::map< std::string, casadi::GenericType* >* x6)"
-// call: "casadi::MapAccum(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,Ref (Const (StdVec CBool)),Ref (Const (StdVec CInt)),CBool,Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5, std::map< std::string, casadi::GenericType* >* x6);
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Function* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, int x5, std::map< std::string, casadi::GenericType* >* x6){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        std::vector< bool > x3_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-        std::map< std::string, casadi::GenericType > x6_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x6);
-
-        return new casadi::MapAccum(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::MapAccum"
-// cppName: "casadi::MapAccum"
-// cWrapperName: "casadi__MapAccum__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "MapAccum")
-// cWrapperRetType: "casadi::MapAccum*"
-// proto: "casadi::MapAccum*\n    casadi__MapAccum__CONSTRUCTOR__3(std::string ** err_msg)"
-// call: "casadi::MapAccum()"
-// params: []
-extern "C"
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__3(std::string ** err_msg);
-casadi::MapAccum*
-    casadi__MapAccum__CONSTRUCTOR__3(std::string ** err_msg){
-    try {
-
-        return new casadi::MapAccum();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "MatrixCommon")===============
-// classType: UserType (Namespace ["casadi"]) (Name "MatrixCommon")
-extern "C"
-void delete_casadi__MatrixCommon(casadi::MatrixCommon* obj);
-void delete_casadi__MatrixCommon(casadi::MatrixCommon* obj){
-    delete obj;
-}
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "NlpBuilder")===============
-// classType: UserType (Namespace ["casadi"]) (Name "NlpBuilder")
-extern "C"
-void delete_casadi__NlpBuilder(casadi::NlpBuilder* obj);
-void delete_casadi__NlpBuilder(casadi::NlpBuilder* obj){
-    delete obj;
-}
-
-// ================== Normal method: "parseNL" ===============
-// class: "casadi::NlpBuilder"
-// cppName: "casadi::NlpBuilder::parseNL"
-// cWrapperName: "casadi__NlpBuilder__parseNL__0"
-// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__NlpBuilder__parseNL__0(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0)"
-// call: "obj->parseNL(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__NlpBuilder__parseNL__0(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0);
-void
-    casadi__NlpBuilder__parseNL__0(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->parseNL(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "parseNL" ===============
-// class: "casadi::NlpBuilder"
-// cppName: "casadi::NlpBuilder::parseNL"
-// cWrapperName: "casadi__NlpBuilder__parseNL__1"
-// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__NlpBuilder__parseNL__1(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
-// call: "obj->parseNL(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-void
-    casadi__NlpBuilder__parseNL__1(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
-void
-    casadi__NlpBuilder__parseNL__1(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
-
-        obj->parseNL(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::NlpBuilder"
-// cppName: "casadi::NlpBuilder::getRepresentation"
-// cWrapperName: "casadi__NlpBuilder__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__NlpBuilder__getRepresentation(std::string ** err_msg, casadi::NlpBuilder* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__NlpBuilder__getRepresentation(std::string ** err_msg, casadi::NlpBuilder* obj);
-std::string*
-    casadi__NlpBuilder__getRepresentation(std::string ** err_msg, casadi::NlpBuilder* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::NlpBuilder"
-// cppName: "casadi::NlpBuilder::getDescription"
-// cWrapperName: "casadi__NlpBuilder__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__NlpBuilder__getDescription(std::string ** err_msg, casadi::NlpBuilder* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__NlpBuilder__getDescription(std::string ** err_msg, casadi::NlpBuilder* obj);
-std::string*
-    casadi__NlpBuilder__getDescription(std::string ** err_msg, casadi::NlpBuilder* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "NlpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-extern "C"
-void delete_casadi__NlpSolver(casadi::NlpSolver* obj);
-void delete_casadi__NlpSolver(casadi::NlpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver"
-// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-// cWrapperRetType: "casadi::NlpSolver*"
-// proto: "casadi::NlpSolver*\n    casadi__NlpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2)"
-// call: "casadi::NlpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))))]
-extern "C"
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2);
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::MX > x2_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x2);
-
-        return new casadi::NlpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver"
-// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-// cWrapperRetType: "casadi::NlpSolver*"
-// proto: "casadi::NlpSolver*\n    casadi__NlpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::NlpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::MX > x2_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::NlpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver"
-// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-// cWrapperRetType: "casadi::NlpSolver*"
-// proto: "casadi::NlpSolver*\n    casadi__NlpSolver__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2)"
-// call: "casadi::NlpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2);
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::SX > x2_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x2);
-
-        return new casadi::NlpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver"
-// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-// cWrapperRetType: "casadi::NlpSolver*"
-// proto: "casadi::NlpSolver*\n    casadi__NlpSolver__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::NlpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::SX > x2_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::NlpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver"
-// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-// cWrapperRetType: "casadi::NlpSolver*"
-// proto: "casadi::NlpSolver*\n    casadi__NlpSolver__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2)"
-// call: "casadi::NlpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2);
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-
-        return new casadi::NlpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver"
-// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-// cWrapperRetType: "casadi::NlpSolver*"
-// proto: "casadi::NlpSolver*\n    casadi__NlpSolver__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::NlpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::NlpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver"
-// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
-// cWrapperRetType: "casadi::NlpSolver*"
-// proto: "casadi::NlpSolver*\n    casadi__NlpSolver__CONSTRUCTOR__6(std::string ** err_msg)"
-// call: "casadi::NlpSolver()"
-// params: []
-extern "C"
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__6(std::string ** err_msg);
-casadi::NlpSolver*
-    casadi__NlpSolver__CONSTRUCTOR__6(std::string ** err_msg){
-    try {
-
-        return new casadi::NlpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::doc"
-// cWrapperName: "casadi__NlpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__NlpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::NlpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__NlpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__NlpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::NlpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getReducedHessian" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::getReducedHessian"
-// cWrapperName: "casadi__NlpSolver__getReducedHessian"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__NlpSolver__getReducedHessian(std::string ** err_msg, casadi::NlpSolver* obj)"
-// call: "obj->getReducedHessian()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__NlpSolver__getReducedHessian(std::string ** err_msg, casadi::NlpSolver* obj);
-casadi::DMatrix*
-    casadi__NlpSolver__getReducedHessian(std::string ** err_msg, casadi::NlpSolver* obj){
-    try {
-
-        casadi::DMatrix ret = obj->getReducedHessian();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getReportConstraints" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::getReportConstraints"
-// cWrapperName: "casadi__NlpSolver__getReportConstraints"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__NlpSolver__getReportConstraints(std::string ** err_msg, casadi::NlpSolver* obj)"
-// call: "obj->getReportConstraints()"
-// params: []
-extern "C"
-std::string*
-    casadi__NlpSolver__getReportConstraints(std::string ** err_msg, casadi::NlpSolver* obj);
-std::string*
-    casadi__NlpSolver__getReportConstraints(std::string ** err_msg, casadi::NlpSolver* obj){
-    try {
-
-        std::string ret = obj->getReportConstraints();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "gradF" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::gradF"
-// cWrapperName: "casadi__NlpSolver__gradF"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__NlpSolver__gradF(std::string ** err_msg, casadi::NlpSolver* obj)"
-// call: "obj->gradF()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__NlpSolver__gradF(std::string ** err_msg, casadi::NlpSolver* obj);
-casadi::Function*
-    casadi__NlpSolver__gradF(std::string ** err_msg, casadi::NlpSolver* obj){
-    try {
-
-        casadi::Function ret = obj->gradF();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::hasPlugin"
-// cWrapperName: "casadi__NlpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__NlpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::NlpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__NlpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__NlpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::NlpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hessLag" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::hessLag"
-// cWrapperName: "casadi__NlpSolver__hessLag"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__NlpSolver__hessLag(std::string ** err_msg, casadi::NlpSolver* obj)"
-// call: "obj->hessLag()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__NlpSolver__hessLag(std::string ** err_msg, casadi::NlpSolver* obj);
-casadi::Function*
-    casadi__NlpSolver__hessLag(std::string ** err_msg, casadi::NlpSolver* obj){
-    try {
-
-        casadi::Function ret = obj->hessLag();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jacG" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::jacG"
-// cWrapperName: "casadi__NlpSolver__jacG"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__NlpSolver__jacG(std::string ** err_msg, casadi::NlpSolver* obj)"
-// call: "obj->jacG()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__NlpSolver__jacG(std::string ** err_msg, casadi::NlpSolver* obj);
-casadi::Function*
-    casadi__NlpSolver__jacG(std::string ** err_msg, casadi::NlpSolver* obj){
-    try {
-
-        casadi::Function ret = obj->jacG();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::loadPlugin"
-// cWrapperName: "casadi__NlpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__NlpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::NlpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__NlpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__NlpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::NlpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "nlp" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::nlp"
-// cWrapperName: "casadi__NlpSolver__nlp"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Function")
-// cWrapperRetType: "casadi::Function*"
-// proto: "casadi::Function*\n    casadi__NlpSolver__nlp(std::string ** err_msg, casadi::NlpSolver* obj)"
-// call: "obj->nlp()"
-// params: []
-extern "C"
-casadi::Function*
-    casadi__NlpSolver__nlp(std::string ** err_msg, casadi::NlpSolver* obj);
-casadi::Function*
-    casadi__NlpSolver__nlp(std::string ** err_msg, casadi::NlpSolver* obj){
-    try {
-
-        casadi::Function ret = obj->nlp();
-        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "reportConstraints" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::reportConstraints"
-// cWrapperName: "casadi__NlpSolver__reportConstraints"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__NlpSolver__reportConstraints(std::string ** err_msg, casadi::NlpSolver* obj)"
-// call: "obj->reportConstraints()"
-// params: []
-extern "C"
-void
-    casadi__NlpSolver__reportConstraints(std::string ** err_msg, casadi::NlpSolver* obj);
-void
-    casadi__NlpSolver__reportConstraints(std::string ** err_msg, casadi::NlpSolver* obj){
-    try {
-
-        obj->reportConstraints();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOptionsFromFile" ===============
-// class: "casadi::NlpSolver"
-// cppName: "casadi::NlpSolver::setOptionsFromFile"
-// cWrapperName: "casadi__NlpSolver__setOptionsFromFile"
-// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__NlpSolver__setOptionsFromFile(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0)"
-// call: "obj->setOptionsFromFile(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__NlpSolver__setOptionsFromFile(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0);
-void
-    casadi__NlpSolver__setOptionsFromFile(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->setOptionsFromFile(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Nullspace")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Nullspace")
-extern "C"
-void delete_casadi__Nullspace(casadi::Nullspace* obj);
-void delete_casadi__Nullspace(casadi::Nullspace* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Nullspace"
-// cppName: "casadi::Nullspace"
-// cWrapperName: "casadi__Nullspace__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Nullspace")
-// cWrapperRetType: "casadi::Nullspace*"
-// proto: "casadi::Nullspace*\n    casadi__Nullspace__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::Nullspace()"
-// params: []
-extern "C"
-casadi::Nullspace*
-    casadi__Nullspace__CONSTRUCTOR(std::string ** err_msg);
-casadi::Nullspace*
-    casadi__Nullspace__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::Nullspace();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")===============
-// classType: UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")
-extern "C"
-void delete_casadi__OptionsFunctionality(casadi::OptionsFunctionality* obj);
-void delete_casadi__OptionsFunctionality(casadi::OptionsFunctionality* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality"
-// cWrapperName: "casadi__OptionsFunctionality__CONSTRUCTOR"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")
-// cWrapperRetType: "casadi::OptionsFunctionality*"
-// proto: "casadi::OptionsFunctionality*\n    casadi__OptionsFunctionality__CONSTRUCTOR(std::string ** err_msg)"
-// call: "casadi::OptionsFunctionality()"
-// params: []
-extern "C"
-casadi::OptionsFunctionality*
-    casadi__OptionsFunctionality__CONSTRUCTOR(std::string ** err_msg);
-casadi::OptionsFunctionality*
-    casadi__OptionsFunctionality__CONSTRUCTOR(std::string ** err_msg){
-    try {
-
-        return new casadi::OptionsFunctionality();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "addOptionRecipe" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::addOptionRecipe"
-// cWrapperName: "casadi__OptionsFunctionality__addOptionRecipe"
-// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))
-// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
-// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__OptionsFunctionality__addOptionRecipe(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0, std::string* x1)"
-// call: "casadi::OptionsFunctionality::addOptionRecipe(x0_, x1_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),Ref (Const StdString)]
-extern "C"
-std::map< std::string, casadi::GenericType* >*
-    casadi__OptionsFunctionality__addOptionRecipe(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0, std::string* x1);
-std::map< std::string, casadi::GenericType* >*
-    casadi__OptionsFunctionality__addOptionRecipe(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0, std::string* x1){
-    try {
-        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        std::map< std::string, casadi::GenericType > ret = casadi::OptionsFunctionality::addOptionRecipe(x0_, x1_);
-        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "copyOptions" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::copyOptions"
-// cWrapperName: "casadi__OptionsFunctionality__copyOptions__0"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__copyOptions__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0)"
-// call: "obj->copyOptions(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")))]
-extern "C"
-void
-    casadi__OptionsFunctionality__copyOptions__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0);
-void
-    casadi__OptionsFunctionality__copyOptions__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0){
-    try {
-        casadi::OptionsFunctionality& x0_ = Marshaling<casadi::OptionsFunctionality&,casadi::OptionsFunctionality*>::marshal(x0);
-
-        obj->copyOptions(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "copyOptions" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::copyOptions"
-// cWrapperName: "casadi__OptionsFunctionality__copyOptions__1"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__copyOptions__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1)"
-// call: "obj->copyOptions(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "OptionsFunctionality"))),CBool]
-extern "C"
-void
-    casadi__OptionsFunctionality__copyOptions__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1);
-void
-    casadi__OptionsFunctionality__copyOptions__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1){
-    try {
-        casadi::OptionsFunctionality& x0_ = Marshaling<casadi::OptionsFunctionality&,casadi::OptionsFunctionality*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->copyOptions(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "dictionary" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::dictionary"
-// cWrapperName: "casadi__OptionsFunctionality__dictionary"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
-// args: "()"
-// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))
-// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
-// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__OptionsFunctionality__dictionary(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
-// call: "obj->dictionary()"
-// params: []
-extern "C"
-std::map< std::string, casadi::GenericType* >*
-    casadi__OptionsFunctionality__dictionary(std::string ** err_msg, casadi::OptionsFunctionality* obj);
-std::map< std::string, casadi::GenericType* >*
-    casadi__OptionsFunctionality__dictionary(std::string ** err_msg, casadi::OptionsFunctionality* obj){
-    try {
-
-        std::map< std::string, casadi::GenericType > ret = obj->dictionary();
-        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOption" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOption"
-// cWrapperName: "casadi__OptionsFunctionality__getOption"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__OptionsFunctionality__getOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOption(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::GenericType*
-    casadi__OptionsFunctionality__getOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-casadi::GenericType*
-    casadi__OptionsFunctionality__getOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::GenericType ret = obj->getOption(x0_);
-        return WrapReturn< casadi::GenericType*, casadi::GenericType >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionAllowed" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionAllowed"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionAllowed"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "GenericType"))
-// cWrapperRetType: "std::vector< casadi::GenericType* >*"
-// proto: "std::vector< casadi::GenericType* >*\n    casadi__OptionsFunctionality__getOptionAllowed(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOptionAllowed(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::vector< casadi::GenericType* >*
-    casadi__OptionsFunctionality__getOptionAllowed(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-std::vector< casadi::GenericType* >*
-    casadi__OptionsFunctionality__getOptionAllowed(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::vector< casadi::GenericType > ret = obj->getOptionAllowed(x0_);
-        return WrapReturn< std::vector< casadi::GenericType* >*, std::vector< casadi::GenericType > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionAllowedIndex" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionAllowedIndex"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionAllowedIndex"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__OptionsFunctionality__getOptionAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOptionAllowedIndex(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__OptionsFunctionality__getOptionAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-int
-    casadi__OptionsFunctionality__getOptionAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        int ret = obj->getOptionAllowedIndex(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionDefault" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionDefault"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionDefault"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
-// cWrapperRetType: "casadi::GenericType*"
-// proto: "casadi::GenericType*\n    casadi__OptionsFunctionality__getOptionDefault(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOptionDefault(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::GenericType*
-    casadi__OptionsFunctionality__getOptionDefault(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-casadi::GenericType*
-    casadi__OptionsFunctionality__getOptionDefault(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::GenericType ret = obj->getOptionDefault(x0_);
-        return WrapReturn< casadi::GenericType*, casadi::GenericType >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionDescription" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionDescription"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionDescription"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__OptionsFunctionality__getOptionDescription(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOptionDescription(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__OptionsFunctionality__getOptionDescription(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-std::string*
-    casadi__OptionsFunctionality__getOptionDescription(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = obj->getOptionDescription(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionEnumValue" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionEnumValue"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionEnumValue"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__OptionsFunctionality__getOptionEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOptionEnumValue(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__OptionsFunctionality__getOptionEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-int
-    casadi__OptionsFunctionality__getOptionEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        int ret = obj->getOptionEnumValue(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionNames" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionNames"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionNames"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
-// args: "()"
-// rettype: StdVec StdString
-// cWrapperRetType: "std::vector< std::string* >*"
-// proto: "std::vector< std::string* >*\n    casadi__OptionsFunctionality__getOptionNames(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
-// call: "obj->getOptionNames()"
-// params: []
-extern "C"
-std::vector< std::string* >*
-    casadi__OptionsFunctionality__getOptionNames(std::string ** err_msg, casadi::OptionsFunctionality* obj);
-std::vector< std::string* >*
-    casadi__OptionsFunctionality__getOptionNames(std::string ** err_msg, casadi::OptionsFunctionality* obj){
-    try {
-
-        std::vector< std::string > ret = obj->getOptionNames();
-        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionType" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionType"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionType"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CEnum (Namespace ["casadi"]) (Name "TypeID")
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__OptionsFunctionality__getOptionType(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOptionType(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__OptionsFunctionality__getOptionType(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-int
-    casadi__OptionsFunctionality__getOptionType(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::TypeID ret = obj->getOptionType(x0_);
-        return WrapReturn< int, casadi::TypeID >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOptionTypeName" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::getOptionTypeName"
-// cWrapperName: "casadi__OptionsFunctionality__getOptionTypeName"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__OptionsFunctionality__getOptionTypeName(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->getOptionTypeName(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__OptionsFunctionality__getOptionTypeName(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-std::string*
-    casadi__OptionsFunctionality__getOptionTypeName(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = obj->getOptionTypeName(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasOption" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::hasOption"
-// cWrapperName: "casadi__OptionsFunctionality__hasOption"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__OptionsFunctionality__hasOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->hasOption(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__OptionsFunctionality__hasOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-int
-    casadi__OptionsFunctionality__hasOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = obj->hasOption(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasSetOption" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::hasSetOption"
-// cWrapperName: "casadi__OptionsFunctionality__hasSetOption"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__OptionsFunctionality__hasSetOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
-// call: "obj->hasSetOption(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__OptionsFunctionality__hasSetOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
-int
-    casadi__OptionsFunctionality__hasSetOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = obj->hasSetOption(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "printOptions" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::printOptions"
-// cWrapperName: "casadi__OptionsFunctionality__printOptions"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__printOptions(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
-// call: "obj->printOptions()"
-// params: []
-extern "C"
-void
-    casadi__OptionsFunctionality__printOptions(std::string ** err_msg, casadi::OptionsFunctionality* obj);
-void
-    casadi__OptionsFunctionality__printOptions(std::string ** err_msg, casadi::OptionsFunctionality* obj){
-    try {
-
-        obj->printOptions();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOption" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::setOption"
-// cWrapperName: "casadi__OptionsFunctionality__setOption__0"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__setOption__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0)"
-// call: "obj->setOption(x0_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-void
-    casadi__OptionsFunctionality__setOption__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0);
-void
-    casadi__OptionsFunctionality__setOption__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0){
-    try {
-        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
-
-        obj->setOption(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOption" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::setOption"
-// cWrapperName: "casadi__OptionsFunctionality__setOption__1"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__setOption__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0, int x1)"
-// call: "obj->setOption(x0_, x1_)"
-// params: [Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),CBool]
-extern "C"
-void
-    casadi__OptionsFunctionality__setOption__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0, int x1);
-void
-    casadi__OptionsFunctionality__setOption__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::map< std::string, casadi::GenericType* >* x0, int x1){
-    try {
-        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->setOption(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOption" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::setOption"
-// cWrapperName: "casadi__OptionsFunctionality__setOption__2"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__setOption__2(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1)"
-// call: "obj->setOption(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType")))]
-extern "C"
-void
-    casadi__OptionsFunctionality__setOption__2(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1);
-void
-    casadi__OptionsFunctionality__setOption__2(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::GenericType& x1_ = Marshaling<casadi::GenericType&,casadi::GenericType*>::marshal(x1);
-
-        obj->setOption(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOptionByAllowedIndex" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::setOptionByAllowedIndex"
-// cWrapperName: "casadi__OptionsFunctionality__setOptionByAllowedIndex"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__setOptionByAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
-// call: "obj->setOptionByAllowedIndex(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-void
-    casadi__OptionsFunctionality__setOptionByAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1);
-void
-    casadi__OptionsFunctionality__setOptionByAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setOptionByAllowedIndex(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOptionByEnumValue" ===============
-// class: "casadi::OptionsFunctionality"
-// cppName: "casadi::OptionsFunctionality::setOptionByEnumValue"
-// cWrapperName: "casadi__OptionsFunctionality__setOptionByEnumValue"
-// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__OptionsFunctionality__setOptionByEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
-// call: "obj->setOptionByEnumValue(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-void
-    casadi__OptionsFunctionality__setOptionByEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1);
-void
-    casadi__OptionsFunctionality__setOptionByEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setOptionByEnumValue(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "QcqpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "QcqpSolver")
-extern "C"
-void delete_casadi__QcqpSolver(casadi::QcqpSolver* obj);
-void delete_casadi__QcqpSolver(casadi::QcqpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::QcqpSolver"
-// cppName: "casadi::QcqpSolver"
-// cWrapperName: "casadi__QcqpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "QcqpSolver")
-// cWrapperRetType: "casadi::QcqpSolver*"
-// proto: "casadi::QcqpSolver*\n    casadi__QcqpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::QcqpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::QcqpSolver*
-    casadi__QcqpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::QcqpSolver*
-    casadi__QcqpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::QcqpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::QcqpSolver"
-// cppName: "casadi::QcqpSolver"
-// cWrapperName: "casadi__QcqpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "QcqpSolver")
-// cWrapperRetType: "casadi::QcqpSolver*"
-// proto: "casadi::QcqpSolver*\n    casadi__QcqpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::QcqpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::QcqpSolver*
-    casadi__QcqpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::QcqpSolver*
-    casadi__QcqpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::QcqpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::QcqpSolver"
-// cppName: "casadi::QcqpSolver"
-// cWrapperName: "casadi__QcqpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "QcqpSolver")
-// cWrapperRetType: "casadi::QcqpSolver*"
-// proto: "casadi::QcqpSolver*\n    casadi__QcqpSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::QcqpSolver()"
-// params: []
-extern "C"
-casadi::QcqpSolver*
-    casadi__QcqpSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::QcqpSolver*
-    casadi__QcqpSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::QcqpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::QcqpSolver"
-// cppName: "casadi::QcqpSolver::doc"
-// cWrapperName: "casadi__QcqpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__QcqpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::QcqpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__QcqpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__QcqpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::QcqpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::QcqpSolver"
-// cppName: "casadi::QcqpSolver::hasPlugin"
-// cWrapperName: "casadi__QcqpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__QcqpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::QcqpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__QcqpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__QcqpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::QcqpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::QcqpSolver"
-// cppName: "casadi::QcqpSolver::loadPlugin"
-// cWrapperName: "casadi__QcqpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__QcqpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::QcqpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__QcqpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__QcqpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::QcqpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "QpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "QpSolver")
-extern "C"
-void delete_casadi__QpSolver(casadi::QpSolver* obj);
-void delete_casadi__QpSolver(casadi::QpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::QpSolver"
-// cppName: "casadi::QpSolver"
-// cWrapperName: "casadi__QpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "QpSolver")
-// cWrapperRetType: "casadi::QpSolver*"
-// proto: "casadi::QpSolver*\n    casadi__QpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::QpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::QpSolver*
-    casadi__QpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::QpSolver*
-    casadi__QpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::QpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::QpSolver"
-// cppName: "casadi::QpSolver"
-// cWrapperName: "casadi__QpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "QpSolver")
-// cWrapperRetType: "casadi::QpSolver*"
-// proto: "casadi::QpSolver*\n    casadi__QpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::QpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::QpSolver*
-    casadi__QpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::QpSolver*
-    casadi__QpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::QpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::QpSolver"
-// cppName: "casadi::QpSolver"
-// cWrapperName: "casadi__QpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "QpSolver")
-// cWrapperRetType: "casadi::QpSolver*"
-// proto: "casadi::QpSolver*\n    casadi__QpSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::QpSolver()"
-// params: []
-extern "C"
-casadi::QpSolver*
-    casadi__QpSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::QpSolver*
-    casadi__QpSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::QpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::QpSolver"
-// cppName: "casadi::QpSolver::doc"
-// cWrapperName: "casadi__QpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__QpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::QpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__QpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__QpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::QpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "generateNativeCode" ===============
-// class: "casadi::QpSolver"
-// cppName: "casadi::QpSolver::generateNativeCode"
-// cWrapperName: "casadi__QpSolver__generateNativeCode"
-// protoArgs: "(std::string ** err_msg, casadi::QpSolver* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__QpSolver__generateNativeCode(std::string ** err_msg, casadi::QpSolver* obj, std::string* x0)"
-// call: "obj->generateNativeCode(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__QpSolver__generateNativeCode(std::string ** err_msg, casadi::QpSolver* obj, std::string* x0);
-void
-    casadi__QpSolver__generateNativeCode(std::string ** err_msg, casadi::QpSolver* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->generateNativeCode(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::QpSolver"
-// cppName: "casadi::QpSolver::hasPlugin"
-// cWrapperName: "casadi__QpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__QpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::QpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__QpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__QpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::QpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::QpSolver"
-// cppName: "casadi::QpSolver::loadPlugin"
-// cWrapperName: "casadi__QpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__QpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::QpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__QpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__QpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::QpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SX")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SX")
-extern "C"
-void delete_casadi__SX(casadi::SX* obj);
-void delete_casadi__SX(casadi::SX* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0)"
-// call: "casadi::SX(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, casadi::DMatrix* x0)"
-// call: "casadi::SX(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, casadi::DMatrix* x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::SX(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, casadi::IMatrix* x0)"
-// call: "casadi::SX(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, casadi::IMatrix* x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, casadi::IMatrix* x0){
-    try {
-        casadi::IMatrix& x0_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
-// call: "casadi::SX(x0_)"
-// params: [Ref (Const (StdVec (StdVec CDouble)))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0){
-    try {
-        std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, double x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, double x0)"
-// call: "casadi::SX(x0_)"
-// params: [CDouble]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, double x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1)"
-// call: "casadi::SX(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
-
-        return new casadi::SX(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::SX(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__8"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::SX(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        return new casadi::SX(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__9"
-// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::SX* x0)"
-// call: "casadi::SX(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::SX* x0);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::SX* x0){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-
-        return new casadi::SX(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX"
-// cWrapperName: "casadi__SX__CONSTRUCTOR__10"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__10(std::string ** err_msg)"
-// call: "casadi::SX()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__10(std::string ** err_msg);
-casadi::SX*
-    casadi__SX__CONSTRUCTOR__10(std::string ** err_msg){
-    try {
-
-        return new casadi::SX();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "T" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::T"
-// cWrapperName: "casadi__SX__T"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__T(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->T()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__T(std::string ** err_msg, casadi::SX* obj);
-casadi::SX*
-    casadi__SX__T(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        casadi::SX ret = obj->T();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "__nonzero__" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::__nonzero__"
-// cWrapperName: "casadi__SX____nonzero__"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->__nonzero__()"
-// params: []
-extern "C"
-int
-    casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->__nonzero__();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "append" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::append"
-// cWrapperName: "casadi__SX__append"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__append(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// call: "obj->append(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-void
-    casadi__SX__append(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
-void
-    casadi__SX__append(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-
-        obj->append(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "appendColumns" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::appendColumns"
-// cWrapperName: "casadi__SX__appendColumns"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__appendColumns(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// call: "obj->appendColumns(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-void
-    casadi__SX__appendColumns(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
-void
-    casadi__SX__appendColumns(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-
-        obj->appendColumns(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "binary" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::binary"
-// cWrapperName: "casadi__SX__binary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// call: "casadi::SX::binary(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
-casadi::SX*
-    casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
-        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
-
-        casadi::SX ret = casadi::SX::binary(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "className" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::className"
-// cWrapperName: "casadi__SX__className"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SX__className(std::string ** err_msg)"
-// call: "casadi::SX::className()"
-// params: []
-extern "C"
-std::string*
-    casadi__SX__className(std::string ** err_msg);
-std::string*
-    casadi__SX__className(std::string ** err_msg){
-    try {
-
-        std::string ret = casadi::SX::className();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clear" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::clear"
-// cWrapperName: "casadi__SX__clear"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__clear(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->clear()"
-// params: []
-extern "C"
-void
-    casadi__SX__clear(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__clear(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->clear();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "colind" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::colind"
-// cWrapperName: "casadi__SX__colind"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__colind(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->colind(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__SX__colind(std::string ** err_msg, casadi::SX* obj, int x0);
-int
-    casadi__SX__colind(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->colind(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "dimString" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::dimString"
-// cWrapperName: "casadi__SX__dimString"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SX__dimString(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->dimString()"
-// params: []
-extern "C"
-std::string*
-    casadi__SX__dimString(std::string ** err_msg, casadi::SX* obj);
-std::string*
-    casadi__SX__dimString(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::string ret = obj->dimString();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::enlarge"
-// cWrapperName: "casadi__SX__enlarge__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__enlarge__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__SX__enlarge__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-void
-    casadi__SX__enlarge__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        obj->enlarge(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::enlarge"
-// cWrapperName: "casadi__SX__enlarge__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__enlarge__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_, x4_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__SX__enlarge__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
-void
-    casadi__SX__enlarge__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::erase"
-// cWrapperName: "casadi__SX__erase__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__erase__0(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0)"
-// call: "obj->erase(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__SX__erase__0(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0);
-void
-    casadi__SX__erase__0(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        obj->erase(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::erase"
-// cWrapperName: "casadi__SX__erase__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__erase__1(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__SX__erase__1(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1);
-void
-    casadi__SX__erase__1(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::erase"
-// cWrapperName: "casadi__SX__erase__2"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__erase__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__SX__erase__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__SX__erase__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->erase(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::erase"
-// cWrapperName: "casadi__SX__erase__3"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__erase__3(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// call: "obj->erase(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__SX__erase__3(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
-void
-    casadi__SX__erase__3(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->erase(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "eye" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::eye"
-// cWrapperName: "casadi__SX__eye"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__eye(std::string ** err_msg, int x0)"
-// call: "casadi::SX::eye(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__eye(std::string ** err_msg, int x0);
-casadi::SX*
-    casadi__SX__eye(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::eye(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::find"
-// cWrapperName: "casadi__SX__find__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__SX__find__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->find()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__SX__find__0(std::string ** err_msg, casadi::SX* obj);
-std::vector< int >*
-    casadi__SX__find__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::vector< int > ret = obj->find();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::find"
-// cWrapperName: "casadi__SX__find__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__SX__find__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->find(x0_)"
-// params: [CBool]
-extern "C"
-std::vector< int >*
-    casadi__SX__find__1(std::string ** err_msg, casadi::SX* obj, int x0);
-std::vector< int >*
-    casadi__SX__find__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        std::vector< int > ret = obj->find(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__2"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__3"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->get(x0_, x1_, x2_, x3_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->get(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__4"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__5"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__6"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->get(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__get__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__SX__get__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->get(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "get" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::get"
-// cWrapperName: "casadi__SX__get__7"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__get__7(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// call: "obj->get(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__SX__get__7(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0);
-void
-    casadi__SX__get__7(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->get(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getColind" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getColind"
-// cWrapperName: "casadi__SX__getColind"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__SX__getColind(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getColind()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__SX__getColind(std::string ** err_msg, casadi::SX* obj);
-std::vector< int >*
-    casadi__SX__getColind(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::vector< int > ret = obj->getColind();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getDep"
-// cWrapperName: "casadi__SX__getDep__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__getDep__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getDep()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__getDep__0(std::string ** err_msg, casadi::SX* obj);
-casadi::SX*
-    casadi__SX__getDep__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        casadi::SX ret = obj->getDep();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDep" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getDep"
-// cWrapperName: "casadi__SX__getDep__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__getDep__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->getDep(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__getDep__1(std::string ** err_msg, casadi::SX* obj, int x0);
-casadi::SX*
-    casadi__SX__getDep__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = obj->getDep(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getElementHash" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getElementHash"
-// cWrapperName: "casadi__SX__getElementHash"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__SX__getElementHash(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getElementHash()"
-// params: []
-extern "C"
-size_t
-    casadi__SX__getElementHash(std::string ** err_msg, casadi::SX* obj);
-size_t
-    casadi__SX__getElementHash(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        size_t ret = obj->getElementHash();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "getEqualityCheckingDepth" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getEqualityCheckingDepth"
-// cWrapperName: "casadi__SX__getEqualityCheckingDepth"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__getEqualityCheckingDepth(std::string ** err_msg)"
-// call: "casadi::SX::getEqualityCheckingDepth()"
-// params: []
-extern "C"
-int
-    casadi__SX__getEqualityCheckingDepth(std::string ** err_msg);
-int
-    casadi__SX__getEqualityCheckingDepth(std::string ** err_msg){
-    try {
-
-        int ret = casadi::SX::getEqualityCheckingDepth();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getIntValue" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getIntValue"
-// cWrapperName: "casadi__SX__getIntValue"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__getIntValue(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getIntValue()"
-// params: []
-extern "C"
-int
-    casadi__SX__getIntValue(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__getIntValue(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->getIntValue();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getNZ"
-// cWrapperName: "casadi__SX__getNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__getNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__getNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__SX__getNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getNZ"
-// cWrapperName: "casadi__SX__getNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__getNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->getNZ(x0_, x1_, x2_)"
-// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__getNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__SX__getNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->getNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getNZ"
-// cWrapperName: "casadi__SX__getNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__getNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// call: "obj->getNZ(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__SX__getNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0);
-void
-    casadi__SX__getNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->getNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getName" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getName"
-// cWrapperName: "casadi__SX__getName"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SX__getName(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getName()"
-// params: []
-extern "C"
-std::string*
-    casadi__SX__getName(std::string ** err_msg, casadi::SX* obj);
-std::string*
-    casadi__SX__getName(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::string ret = obj->getName();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNdeps" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getNdeps"
-// cWrapperName: "casadi__SX__getNdeps"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__getNdeps(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getNdeps()"
-// params: []
-extern "C"
-int
-    casadi__SX__getNdeps(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__getNdeps(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->getNdeps();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRow" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getRow"
-// cWrapperName: "casadi__SX__getRow"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__SX__getRow(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getRow()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__SX__getRow(std::string ** err_msg, casadi::SX* obj);
-std::vector< int >*
-    casadi__SX__getRow(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::vector< int > ret = obj->getRow();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getSparsity" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getSparsity"
-// cWrapperName: "casadi__SX__getSparsity"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__SX__getSparsity(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getSparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__SX__getSparsity(std::string ** err_msg, casadi::SX* obj);
-casadi::Sparsity*
-    casadi__SX__getSparsity(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        casadi::Sparsity ret = obj->getSparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getSym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getSym"
-// cWrapperName: "casadi__SX__getSym"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__getSym(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// call: "obj->getSym(x0_)"
-// params: [Ref (StdVec CDouble)]
-extern "C"
-void
-    casadi__SX__getSym(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0);
-void
-    casadi__SX__getSym(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->getSym(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getValue" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getValue"
-// cWrapperName: "casadi__SX__getValue__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__SX__getValue__0(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->getValue(x0_)"
-// params: [CInt]
-extern "C"
-double
-    casadi__SX__getValue__0(std::string ** err_msg, casadi::SX* obj, int x0);
-double
-    casadi__SX__getValue__0(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        double ret = obj->getValue(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getValue" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getValue"
-// cWrapperName: "casadi__SX__getValue__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__SX__getValue__1(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getValue()"
-// params: []
-extern "C"
-double
-    casadi__SX__getValue__1(std::string ** err_msg, casadi::SX* obj);
-double
-    casadi__SX__getValue__1(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        double ret = obj->getValue();
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasDuplicates" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::hasDuplicates"
-// cWrapperName: "casadi__SX__hasDuplicates"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__hasDuplicates(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->hasDuplicates()"
-// params: []
-extern "C"
-int
-    casadi__SX__hasDuplicates(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__hasDuplicates(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->hasDuplicates();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::hasNZ"
-// cWrapperName: "casadi__SX__hasNZ"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__hasNZ(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
-// call: "obj->hasNZ(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-int
-    casadi__SX__hasNZ(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
-int
-    casadi__SX__hasNZ(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        bool ret = obj->hasNZ(x0_, x1_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasNonStructuralZeros" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::hasNonStructuralZeros"
-// cWrapperName: "casadi__SX__hasNonStructuralZeros"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__hasNonStructuralZeros(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->hasNonStructuralZeros()"
-// params: []
-extern "C"
-int
-    casadi__SX__hasNonStructuralZeros(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__hasNonStructuralZeros(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->hasNonStructuralZeros();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::inf"
-// cWrapperName: "casadi__SX__inf__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::SX::inf(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::SX*
-    casadi__SX__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::inf(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::inf"
-// cWrapperName: "casadi__SX__inf__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__inf__1(std::string ** err_msg)"
-// call: "casadi::SX::inf()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__inf__1(std::string ** err_msg);
-casadi::SX*
-    casadi__SX__inf__1(std::string ** err_msg){
-    try {
-
-        casadi::SX ret = casadi::SX::inf();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::inf"
-// cWrapperName: "casadi__SX__inf__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__inf__2(std::string ** err_msg, int x0)"
-// call: "casadi::SX::inf(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__inf__2(std::string ** err_msg, int x0);
-casadi::SX*
-    casadi__SX__inf__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::inf(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::inf"
-// cWrapperName: "casadi__SX__inf__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__inf__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::SX::inf(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__inf__3(std::string ** err_msg, int x0, int x1);
-casadi::SX*
-    casadi__SX__inf__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::inf(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "inf" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::inf"
-// cWrapperName: "casadi__SX__inf__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::SX::inf(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::SX*
-    casadi__SX__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::SX*
-    casadi__SX__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::inf(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isCommutative" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isCommutative"
-// cWrapperName: "casadi__SX__isCommutative"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isCommutative(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isCommutative()"
-// params: []
-extern "C"
-int
-    casadi__SX__isCommutative(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isCommutative(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isCommutative();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isConstant" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isConstant"
-// cWrapperName: "casadi__SX__isConstant"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isConstant(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isConstant()"
-// params: []
-extern "C"
-int
-    casadi__SX__isConstant(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isConstant(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isConstant();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isIdentity" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isIdentity"
-// cWrapperName: "casadi__SX__isIdentity"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isIdentity(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isIdentity()"
-// params: []
-extern "C"
-int
-    casadi__SX__isIdentity(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isIdentity(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isIdentity();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isInteger" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isInteger"
-// cWrapperName: "casadi__SX__isInteger"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isInteger(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isInteger()"
-// params: []
-extern "C"
-int
-    casadi__SX__isInteger(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isInteger(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isInteger();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isLeaf" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isLeaf"
-// cWrapperName: "casadi__SX__isLeaf"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isLeaf(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isLeaf()"
-// params: []
-extern "C"
-int
-    casadi__SX__isLeaf(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isLeaf(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isLeaf();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isMinusOne" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isMinusOne"
-// cWrapperName: "casadi__SX__isMinusOne"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isMinusOne(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isMinusOne()"
-// params: []
-extern "C"
-int
-    casadi__SX__isMinusOne(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isMinusOne(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isMinusOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isOne" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isOne"
-// cWrapperName: "casadi__SX__isOne"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isOne(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isOne()"
-// params: []
-extern "C"
-int
-    casadi__SX__isOne(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isOne(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isOne();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isRegular" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isRegular"
-// cWrapperName: "casadi__SX__isRegular"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isRegular(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isRegular()"
-// params: []
-extern "C"
-int
-    casadi__SX__isRegular(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isRegular(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isRegular();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSlice" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isSlice"
-// cWrapperName: "casadi__SX__isSlice__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isSlice__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isSlice()"
-// params: []
-extern "C"
-int
-    casadi__SX__isSlice__0(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isSlice__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isSlice();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSlice" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isSlice"
-// cWrapperName: "casadi__SX__isSlice__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isSlice__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->isSlice(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__SX__isSlice__1(std::string ** err_msg, casadi::SX* obj, int x0);
-int
-    casadi__SX__isSlice__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isSlice(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSmooth" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isSmooth"
-// cWrapperName: "casadi__SX__isSmooth"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isSmooth(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isSmooth()"
-// params: []
-extern "C"
-int
-    casadi__SX__isSmooth(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isSmooth(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isSmooth();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isSymbolic" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isSymbolic"
-// cWrapperName: "casadi__SX__isSymbolic"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isSymbolic(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isSymbolic()"
-// params: []
-extern "C"
-int
-    casadi__SX__isSymbolic(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isSymbolic(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isSymbolic();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isValidInput" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isValidInput"
-// cWrapperName: "casadi__SX__isValidInput"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isValidInput(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isValidInput()"
-// params: []
-extern "C"
-int
-    casadi__SX__isValidInput(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isValidInput(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isValidInput();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isZero" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isZero"
-// cWrapperName: "casadi__SX__isZero"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isZero(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isZero()"
-// params: []
-extern "C"
-int
-    casadi__SX__isZero(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isZero(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isZero();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "iscolumn" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::iscolumn"
-// cWrapperName: "casadi__SX__iscolumn"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__iscolumn(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->iscolumn()"
-// params: []
-extern "C"
-int
-    casadi__SX__iscolumn(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__iscolumn(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->iscolumn();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isdense" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isdense"
-// cWrapperName: "casadi__SX__isdense"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isdense(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isdense()"
-// params: []
-extern "C"
-int
-    casadi__SX__isdense(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isdense(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isdense();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isempty"
-// cWrapperName: "casadi__SX__isempty__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isempty__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isempty()"
-// params: []
-extern "C"
-int
-    casadi__SX__isempty__0(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isempty__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isempty();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isempty"
-// cWrapperName: "casadi__SX__isempty__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isempty__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->isempty(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__SX__isempty__1(std::string ** err_msg, casadi::SX* obj, int x0);
-int
-    casadi__SX__isempty__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isempty(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isrow" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isrow"
-// cWrapperName: "casadi__SX__isrow"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isrow(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isrow()"
-// params: []
-extern "C"
-int
-    casadi__SX__isrow(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isrow(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isrow();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isscalar"
-// cWrapperName: "casadi__SX__isscalar__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isscalar__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isscalar()"
-// params: []
-extern "C"
-int
-    casadi__SX__isscalar__0(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isscalar__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isscalar();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isscalar"
-// cWrapperName: "casadi__SX__isscalar__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isscalar__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->isscalar(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__SX__isscalar__1(std::string ** err_msg, casadi::SX* obj, int x0);
-int
-    casadi__SX__isscalar__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isscalar(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "issquare" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::issquare"
-// cWrapperName: "casadi__SX__issquare"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__issquare(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->issquare()"
-// params: []
-extern "C"
-int
-    casadi__SX__issquare(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__issquare(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->issquare();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istril" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::istril"
-// cWrapperName: "casadi__SX__istril"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__istril(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->istril()"
-// params: []
-extern "C"
-int
-    casadi__SX__istril(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__istril(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->istril();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istriu" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::istriu"
-// cWrapperName: "casadi__SX__istriu"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__istriu(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->istriu()"
-// params: []
-extern "C"
-int
-    casadi__SX__istriu(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__istriu(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->istriu();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isvector" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::isvector"
-// cWrapperName: "casadi__SX__isvector"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__isvector(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->isvector()"
-// params: []
-extern "C"
-int
-    casadi__SX__isvector(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__isvector(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        bool ret = obj->isvector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "makeSparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::makeSparse"
-// cWrapperName: "casadi__SX__makeSparse__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__makeSparse__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->makeSparse()"
-// params: []
-extern "C"
-void
-    casadi__SX__makeSparse__0(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__makeSparse__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->makeSparse();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "makeSparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::makeSparse"
-// cWrapperName: "casadi__SX__makeSparse__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__makeSparse__1(std::string ** err_msg, casadi::SX* obj, double x0)"
-// call: "obj->makeSparse(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__SX__makeSparse__1(std::string ** err_msg, casadi::SX* obj, double x0);
-void
-    casadi__SX__makeSparse__1(std::string ** err_msg, casadi::SX* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->makeSparse(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "matrix_matrix" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::matrix_matrix"
-// cWrapperName: "casadi__SX__matrix_matrix"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// call: "casadi::SX::matrix_matrix(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
-casadi::SX*
-    casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
-        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
-
-        casadi::SX ret = casadi::SX::matrix_matrix(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "matrix_scalar" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::matrix_scalar"
-// cWrapperName: "casadi__SX__matrix_scalar"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// call: "casadi::SX::matrix_scalar(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
-casadi::SX*
-    casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
-        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
-
-        casadi::SX ret = casadi::SX::matrix_scalar(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nan"
-// cWrapperName: "casadi__SX__nan__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::SX::nan(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::SX*
-    casadi__SX__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::nan(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nan"
-// cWrapperName: "casadi__SX__nan__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__nan__1(std::string ** err_msg)"
-// call: "casadi::SX::nan()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__nan__1(std::string ** err_msg);
-casadi::SX*
-    casadi__SX__nan__1(std::string ** err_msg){
-    try {
-
-        casadi::SX ret = casadi::SX::nan();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nan"
-// cWrapperName: "casadi__SX__nan__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__nan__2(std::string ** err_msg, int x0)"
-// call: "casadi::SX::nan(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__nan__2(std::string ** err_msg, int x0);
-casadi::SX*
-    casadi__SX__nan__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::nan(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nan"
-// cWrapperName: "casadi__SX__nan__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__nan__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::SX::nan(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__nan__3(std::string ** err_msg, int x0, int x1);
-casadi::SX*
-    casadi__SX__nan__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::nan(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "nan" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nan"
-// cWrapperName: "casadi__SX__nan__4"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::SX::nan(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::SX*
-    casadi__SX__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::SX*
-    casadi__SX__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::nan(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nnz" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nnz"
-// cWrapperName: "casadi__SX__nnz"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__nnz(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->nnz()"
-// params: []
-extern "C"
-int
-    casadi__SX__nnz(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__nnz(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->nnz();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nonzeros" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nonzeros"
-// cWrapperName: "casadi__SX__nonzeros"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdVec CDouble
-// cWrapperRetType: "std::vector< double >*"
-// proto: "std::vector< double >*\n    casadi__SX__nonzeros(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->nonzeros()"
-// params: []
-extern "C"
-std::vector< double >*
-    casadi__SX__nonzeros(std::string ** err_msg, casadi::SX* obj);
-std::vector< double >*
-    casadi__SX__nonzeros(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::vector< double > ret = obj->nonzeros();
-        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nonzeros_int" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::nonzeros_int"
-// cWrapperName: "casadi__SX__nonzeros_int"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__SX__nonzeros_int(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->nonzeros_int()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__SX__nonzeros_int(std::string ** err_msg, casadi::SX* obj);
-std::vector< int >*
-    casadi__SX__nonzeros_int(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::vector< int > ret = obj->nonzeros_int();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::numel"
-// cWrapperName: "casadi__SX__numel__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__numel__0(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->numel(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__SX__numel__0(std::string ** err_msg, casadi::SX* obj, int x0);
-int
-    casadi__SX__numel__0(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->numel(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::numel"
-// cWrapperName: "casadi__SX__numel__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__numel__1(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->numel()"
-// params: []
-extern "C"
-int
-    casadi__SX__numel__1(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__numel__1(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->numel();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::ones"
-// cWrapperName: "casadi__SX__ones__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::SX::ones(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::SX*
-    casadi__SX__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::ones(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::ones"
-// cWrapperName: "casadi__SX__ones__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::SX::ones(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::SX*
-    casadi__SX__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::SX*
-    casadi__SX__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::ones(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::ones"
-// cWrapperName: "casadi__SX__ones__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__ones__2(std::string ** err_msg)"
-// call: "casadi::SX::ones()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__ones__2(std::string ** err_msg);
-casadi::SX*
-    casadi__SX__ones__2(std::string ** err_msg){
-    try {
-
-        casadi::SX ret = casadi::SX::ones();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::ones"
-// cWrapperName: "casadi__SX__ones__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__ones__3(std::string ** err_msg, int x0)"
-// call: "casadi::SX::ones(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__ones__3(std::string ** err_msg, int x0);
-casadi::SX*
-    casadi__SX__ones__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::ones(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "ones" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::ones"
-// cWrapperName: "casadi__SX__ones__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__ones__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::SX::ones(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__ones__4(std::string ** err_msg, int x0, int x1);
-casadi::SX*
-    casadi__SX__ones__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::ones(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator +" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::operator +"
-// cWrapperName: "casadi__SX__operator_plus"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__operator_plus(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->operator +()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__operator_plus(std::string ** err_msg, casadi::SX* obj);
-casadi::SX*
-    casadi__SX__operator_plus(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        casadi::SX ret = obj->operator +();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator -" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::operator -"
-// cWrapperName: "casadi__SX__operator_minus"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__operator_minus(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->operator -()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__operator_minus(std::string ** err_msg, casadi::SX* obj);
-casadi::SX*
-    casadi__SX__operator_minus(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        casadi::SX ret = obj->operator -();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "printDense" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::printDense"
-// cWrapperName: "casadi__SX__printDense"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__printDense(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->printDense()"
-// params: []
-extern "C"
-void
-    casadi__SX__printDense(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__printDense(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->printDense();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printScalar" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::printScalar"
-// cWrapperName: "casadi__SX__printScalar"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__printScalar(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->printScalar()"
-// params: []
-extern "C"
-void
-    casadi__SX__printScalar(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__printScalar(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->printScalar();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printSparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::printSparse"
-// cWrapperName: "casadi__SX__printSparse"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__printSparse(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->printSparse()"
-// params: []
-extern "C"
-void
-    casadi__SX__printSparse(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__printSparse(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->printSparse();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printSplit" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::printSplit"
-// cWrapperName: "casadi__SX__printSplit"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__printSplit(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
-// call: "obj->printSplit(x0_, x1_)"
-// params: [Ref (StdVec StdString),Ref (StdVec StdString)]
-extern "C"
-void
-    casadi__SX__printSplit(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1);
-void
-    casadi__SX__printSplit(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >* x0, std::vector< std::string* >* x1){
-    try {
-        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);
-        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);
-
-        obj->printSplit(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printVector" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::printVector"
-// cWrapperName: "casadi__SX__printVector"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__printVector(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->printVector()"
-// params: []
-extern "C"
-void
-    casadi__SX__printVector(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__printVector(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->printVector();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printme" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::printme"
-// cWrapperName: "casadi__SX__printme"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// call: "obj->printme(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
-casadi::SX*
-    casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-
-        casadi::SX ret = obj->printme(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "remove" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::remove"
-// cWrapperName: "casadi__SX__remove"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->remove(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->remove(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reserve" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::reserve"
-// cWrapperName: "casadi__SX__reserve__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
-// call: "obj->reserve(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
-void
-    casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->reserve(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reserve" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::reserve"
-// cWrapperName: "casadi__SX__reserve__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->reserve(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0);
-void
-    casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        obj->reserve(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resetInput" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::resetInput"
-// cWrapperName: "casadi__SX__resetInput"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__resetInput(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->resetInput()"
-// params: []
-extern "C"
-void
-    casadi__SX__resetInput(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__resetInput(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->resetInput();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resize" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::resize"
-// cWrapperName: "casadi__SX__resize"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
-// call: "obj->resize(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
-void
-    casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->resize(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "row" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::row"
-// cWrapperName: "casadi__SX__row"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__row(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->row(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__SX__row(std::string ** err_msg, casadi::SX* obj, int x0);
-int
-    casadi__SX__row(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->row(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sanityCheck"
-// cWrapperName: "casadi__SX__sanityCheck__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__sanityCheck__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->sanityCheck()"
-// params: []
-extern "C"
-void
-    casadi__SX__sanityCheck__0(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__sanityCheck__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->sanityCheck();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sanityCheck"
-// cWrapperName: "casadi__SX__sanityCheck__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__sanityCheck__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->sanityCheck(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__SX__sanityCheck__1(std::string ** err_msg, casadi::SX* obj, int x0);
-void
-    casadi__SX__sanityCheck__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->sanityCheck(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "scalar_matrix" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::scalar_matrix"
-// cWrapperName: "casadi__SX__scalar_matrix"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
-// call: "casadi::SX::scalar_matrix(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
-casadi::SX*
-    casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
-        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
-
-        casadi::SX ret = casadi::SX::scalar_matrix(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3);
-void
-    casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::IMatrix* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3);
-void
-    casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2, casadi::Slice* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__2"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3);
-void
-    casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IMatrix* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::IMatrix& x3_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__3"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
-// call: "obj->set(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
-void
-    casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
-
-        obj->set(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__4"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2);
-void
-    casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__5"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__6"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->set(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__set__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__SX__set__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->set(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__7"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__7(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// call: "obj->set(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__SX__set__7(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0);
-void
-    casadi__SX__set__7(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__8"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__8(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0, int x1)"
-// call: "obj->set(x0_, x1_)"
-// params: [Ref (Const (StdVec CDouble)),CBool]
-extern "C"
-void
-    casadi__SX__set__8(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0, int x1);
-void
-    casadi__SX__set__8(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0, int x1){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        obj->set(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__9"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__9(std::string ** err_msg, casadi::SX* obj, double x0)"
-// call: "obj->set(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__SX__set__9(std::string ** err_msg, casadi::SX* obj, double x0);
-void
-    casadi__SX__set__9(std::string ** err_msg, casadi::SX* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "set" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::set"
-// cWrapperName: "casadi__SX__set__10"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__set__10(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
-// call: "obj->set(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-void
-    casadi__SX__set__10(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
-void
-    casadi__SX__set__10(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-
-        obj->set(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setEqualityCheckingDepth"
-// cWrapperName: "casadi__SX__setEqualityCheckingDepth__0"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg)"
-// call: "casadi::SX::setEqualityCheckingDepth()"
-// params: []
-extern "C"
-void
-    casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg);
-void
-    casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg){
-    try {
-
-        casadi::SX::setEqualityCheckingDepth();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setEqualityCheckingDepth" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setEqualityCheckingDepth"
-// cWrapperName: "casadi__SX__setEqualityCheckingDepth__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
-// call: "casadi::SX::setEqualityCheckingDepth(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
-void
-    casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX::setEqualityCheckingDepth(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setNZ"
-// cWrapperName: "casadi__SX__setNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
-extern "C"
-void
-    casadi__SX__setNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2);
-void
-    casadi__SX__setNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::IMatrix& x2_ = Marshaling<casadi::IMatrix&,casadi::IMatrix*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setNZ"
-// cWrapperName: "casadi__SX__setNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
-// call: "obj->setNZ(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-void
-    casadi__SX__setNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2);
-void
-    casadi__SX__setNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2){
-    try {
-        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
-
-        obj->setNZ(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setNZ"
-// cWrapperName: "casadi__SX__setNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// call: "obj->setNZ(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__SX__setNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0);
-void
-    casadi__SX__setNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->setNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setNZ" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setNZ"
-// cWrapperName: "casadi__SX__setNZ__3"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setNZ__3(std::string ** err_msg, casadi::SX* obj, double x0)"
-// call: "obj->setNZ(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__SX__setNZ__3(std::string ** err_msg, casadi::SX* obj, double x0);
-void
-    casadi__SX__setNZ__3(std::string ** err_msg, casadi::SX* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->setNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setPrecision" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setPrecision"
-// cWrapperName: "casadi__SX__setPrecision"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setPrecision(std::string ** err_msg, int x0)"
-// call: "casadi::SX::setPrecision(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__SX__setPrecision(std::string ** err_msg, int x0);
-void
-    casadi__SX__setPrecision(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX::setPrecision(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setScientific" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setScientific"
-// cWrapperName: "casadi__SX__setScientific"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setScientific(std::string ** err_msg, int x0)"
-// call: "casadi::SX::setScientific(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__SX__setScientific(std::string ** err_msg, int x0);
-void
-    casadi__SX__setScientific(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::SX::setScientific(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setSym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setSym"
-// cWrapperName: "casadi__SX__setSym"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setSym(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0)"
-// call: "obj->setSym(x0_)"
-// params: [Ref (Const (StdVec CDouble))]
-extern "C"
-void
-    casadi__SX__setSym(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0);
-void
-    casadi__SX__setSym(std::string ** err_msg, casadi::SX* obj, std::vector< double >* x0){
-    try {
-        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
-
-        obj->setSym(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setValue" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setValue"
-// cWrapperName: "casadi__SX__setValue__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, double x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setValue__0(std::string ** err_msg, casadi::SX* obj, double x0, int x1)"
-// call: "obj->setValue(x0_, x1_)"
-// params: [CDouble,CInt]
-extern "C"
-void
-    casadi__SX__setValue__0(std::string ** err_msg, casadi::SX* obj, double x0, int x1);
-void
-    casadi__SX__setValue__0(std::string ** err_msg, casadi::SX* obj, double x0, int x1){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setValue(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setValue" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setValue"
-// cWrapperName: "casadi__SX__setValue__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, double x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setValue__1(std::string ** err_msg, casadi::SX* obj, double x0)"
-// call: "obj->setValue(x0_)"
-// params: [CDouble]
-extern "C"
-void
-    casadi__SX__setValue__1(std::string ** err_msg, casadi::SX* obj, double x0);
-void
-    casadi__SX__setValue__1(std::string ** err_msg, casadi::SX* obj, double x0){
-    try {
-        double x0_ = Marshaling<double,double>::marshal(x0);
-
-        obj->setValue(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "setWidth" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setWidth"
-// cWrapperName: "casadi__SX__setWidth"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setWidth(std::string ** err_msg, int x0)"
-// call: "casadi::SX::setWidth(x0_)"
-// params: [CInt]
-extern "C"
-void
-    casadi__SX__setWidth(std::string ** err_msg, int x0);
-void
-    casadi__SX__setWidth(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX::setWidth(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setZero" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::setZero"
-// cWrapperName: "casadi__SX__setZero"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SX__setZero(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->setZero()"
-// params: []
-extern "C"
-void
-    casadi__SX__setZero(std::string ** err_msg, casadi::SX* obj);
-void
-    casadi__SX__setZero(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        obj->setZero();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::shape"
-// cWrapperName: "casadi__SX__shape__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__shape__0(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->shape(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__SX__shape__0(std::string ** err_msg, casadi::SX* obj, int x0);
-int
-    casadi__SX__shape__0(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->shape(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::shape"
-// cWrapperName: "casadi__SX__shape__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__SX__shape__1(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->shape()"
-// params: []
-extern "C"
-std::pair< int, int >*
-    casadi__SX__shape__1(std::string ** err_msg, casadi::SX* obj);
-std::pair< int, int >*
-    casadi__SX__shape__1(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::pair< int, int > ret = obj->shape();
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::size"
-// cWrapperName: "casadi__SX__size"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__size(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->size()"
-// params: []
-extern "C"
-int
-    casadi__SX__size(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__size(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->size();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size1" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::size1"
-// cWrapperName: "casadi__SX__size1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__size1(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->size1()"
-// params: []
-extern "C"
-int
-    casadi__SX__size1(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__size1(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->size1();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size2" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::size2"
-// cWrapperName: "casadi__SX__size2"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__size2(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->size2()"
-// params: []
-extern "C"
-int
-    casadi__SX__size2(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__size2(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->size2();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeD" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sizeD"
-// cWrapperName: "casadi__SX__sizeD"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__sizeD(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->sizeD()"
-// params: []
-extern "C"
-int
-    casadi__SX__sizeD(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__sizeD(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->sizeD();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeL" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sizeL"
-// cWrapperName: "casadi__SX__sizeL"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__sizeL(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->sizeL()"
-// params: []
-extern "C"
-int
-    casadi__SX__sizeL(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__sizeL(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->sizeL();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeU" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sizeU"
-// cWrapperName: "casadi__SX__sizeU"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SX__sizeU(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->sizeU()"
-// params: []
-extern "C"
-int
-    casadi__SX__sizeU(std::string ** err_msg, casadi::SX* obj);
-int
-    casadi__SX__sizeU(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        int ret = obj->sizeU();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sparse"
-// cWrapperName: "casadi__SX__sparse__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1)"
-// call: "casadi::SX::sparse(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1);
-casadi::SX*
-    casadi__SX__sparse__0(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::sparse(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sparse"
-// cWrapperName: "casadi__SX__sparse__1"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sparse__1(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::SX::sparse(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__sparse__1(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::SX*
-    casadi__SX__sparse__1(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::sparse(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sparse"
-// cWrapperName: "casadi__SX__sparse__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sparse__2(std::string ** err_msg)"
-// call: "casadi::SX::sparse()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__sparse__2(std::string ** err_msg);
-casadi::SX*
-    casadi__SX__sparse__2(std::string ** err_msg){
-    try {
-
-        casadi::SX ret = casadi::SX::sparse();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sparse"
-// cWrapperName: "casadi__SX__sparse__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sparse__3(std::string ** err_msg, int x0)"
-// call: "casadi::SX::sparse(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__sparse__3(std::string ** err_msg, int x0);
-casadi::SX*
-    casadi__SX__sparse__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::sparse(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sparse"
-// cWrapperName: "casadi__SX__sparse__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sparse__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::SX::sparse(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__sparse__4(std::string ** err_msg, int x0, int x1);
-casadi::SX*
-    casadi__SX__sparse__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::sparse(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sparsity" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sparsity"
-// cWrapperName: "casadi__SX__sparsity"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__SX__sparsity(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->sparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__SX__sparsity(std::string ** err_msg, casadi::SX* obj);
-casadi::Sparsity*
-    casadi__SX__sparsity(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        casadi::Sparsity ret = obj->sparsity();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
-// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
-// proto: "std::vector< std::vector< casadi::SX* >* >*\n    casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
-// call: "casadi::SX::sym(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::SX* >* >*
-    casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
-std::vector< std::vector< casadi::SX* >* >*
-    casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
-// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
-// proto: "std::vector< std::vector< casadi::SX* >* >*\n    casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
-// call: "casadi::SX::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
-extern "C"
-std::vector< std::vector< casadi::SX* >* >*
-    casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
-std::vector< std::vector< casadi::SX* >* >*
-    casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
-// call: "casadi::SX::sym(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CInt,CInt]
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
-std::vector< casadi::SX* >*
-    casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        std::vector< casadi::SX > ret = casadi::SX::sym(x0_, x1_, x2_, x3_);
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
-// call: "casadi::SX::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
-std::vector< casadi::SX* >*
-    casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        std::vector< casadi::SX > ret = casadi::SX::sym(x0_, x1_, x2_);
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// call: "casadi::SX::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::SX*
-    casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
-casadi::SX*
-    casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::sym(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
-// call: "casadi::SX::sym(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
-casadi::SX*
-    casadi__SX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::sym(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sym__6(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SX::sym(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SX__sym__6(std::string ** err_msg, std::string* x0);
-casadi::SX*
-    casadi__SX__sym__6(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::sym(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1)"
-// call: "casadi::SX::sym(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1);
-casadi::SX*
-    casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::sym(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sym" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::sym"
-// cWrapperName: "casadi__SX__sym__8"
-// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
-// call: "casadi::SX::sym(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
-casadi::SX*
-    casadi__SX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        casadi::SX ret = casadi::SX::sym(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toSlice" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::toSlice"
-// cWrapperName: "casadi__SX__toSlice__0"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__SX__toSlice__0(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->toSlice()"
-// params: []
-extern "C"
-casadi::Slice*
-    casadi__SX__toSlice__0(std::string ** err_msg, casadi::SX* obj);
-casadi::Slice*
-    casadi__SX__toSlice__0(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        casadi::Slice ret = obj->toSlice();
-        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toSlice" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::toSlice"
-// cWrapperName: "casadi__SX__toSlice__1"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__SX__toSlice__1(std::string ** err_msg, casadi::SX* obj, int x0)"
-// call: "obj->toSlice(x0_)"
-// params: [CBool]
-extern "C"
-casadi::Slice*
-    casadi__SX__toSlice__1(std::string ** err_msg, casadi::SX* obj, int x0);
-casadi::Slice*
-    casadi__SX__toSlice__1(std::string ** err_msg, casadi::SX* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::Slice ret = obj->toSlice(x0_);
-        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::triplet"
-// cWrapperName: "casadi__SX__triplet__0"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3)"
-// call: "casadi::SX::triplet(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3);
-casadi::SX*
-    casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
-        std::pair< int, int > x3_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x3);
-
-        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::triplet"
-// cWrapperName: "casadi__SX__triplet__1"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4)"
-// call: "casadi::SX::triplet(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4);
-casadi::SX*
-    casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-        int x4_ = Marshaling<int,int>::marshal(x4);
-
-        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::triplet"
-// cWrapperName: "casadi__SX__triplet__2"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2)"
-// call: "casadi::SX::triplet(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2);
-casadi::SX*
-    casadi__SX__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
-
-        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "unary" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::unary"
-// cWrapperName: "casadi__SX__unary"
-// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1)"
-// call: "casadi::SX::unary(x0_, x1_)"
-// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
-extern "C"
-casadi::SX*
-    casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1);
-casadi::SX*
-    casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::unary(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::zeros"
-// cWrapperName: "casadi__SX__zeros__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::SX::zeros(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::SX*
-    casadi__SX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::SX*
-    casadi__SX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::zeros(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::zeros"
-// cWrapperName: "casadi__SX__zeros__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
-// call: "casadi::SX::zeros(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::SX*
-    casadi__SX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
-casadi::SX*
-    casadi__SX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::zeros(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::zeros"
-// cWrapperName: "casadi__SX__zeros__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__zeros__2(std::string ** err_msg)"
-// call: "casadi::SX::zeros()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SX__zeros__2(std::string ** err_msg);
-casadi::SX*
-    casadi__SX__zeros__2(std::string ** err_msg){
-    try {
-
-        casadi::SX ret = casadi::SX::zeros();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::zeros"
-// cWrapperName: "casadi__SX__zeros__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__zeros__3(std::string ** err_msg, int x0)"
-// call: "casadi::SX::zeros(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__zeros__3(std::string ** err_msg, int x0);
-casadi::SX*
-    casadi__SX__zeros__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = casadi::SX::zeros(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "zeros" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::zeros"
-// cWrapperName: "casadi__SX__zeros__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SX__zeros__4(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::SX::zeros(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SX__zeros__4(std::string ** err_msg, int x0, int x1);
-casadi::SX*
-    casadi__SX__zeros__4(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = casadi::SX::zeros(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getRepresentation"
-// cWrapperName: "casadi__SX__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj);
-std::string*
-    casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::SX"
-// cppName: "casadi::SX::getDescription"
-// cWrapperName: "casadi__SX__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj);
-std::string*
-    casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SXElement")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SXElement")
-extern "C"
-void delete_casadi__SXElement(casadi::SXElement* obj);
-void delete_casadi__SXElement(casadi::SXElement* obj){
-    delete obj;
-}
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SXFunction")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SXFunction")
-extern "C"
-void delete_casadi__SXFunction(casadi::SXFunction* obj);
-void delete_casadi__SXFunction(casadi::SXFunction* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2)"
-// call: "casadi::SXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString)))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x2);
-
-        return new casadi::SXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::SXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::SXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2)"
-// call: "casadi::SXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString)))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x2);
-
-        return new casadi::SXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::SXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x2_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::SXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2)"
-// call: "casadi::SXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
-
-        return new casadi::SXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::SXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdPair (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))) (StdVec StdString))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > > x1_ = Marshaling<std::pair< std::map< std::string, casadi::SX >, std::vector< std::string > >,std::pair< std::map< std::string, casadi::SX* >*, std::vector< std::string* >* >*>::marshal(x1);
-        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::SXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
-// call: "casadi::SXFunction(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
-
-        return new casadi::SXFunction(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::SXFunction(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
-        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::SXFunction(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__8"
-// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__8(std::string ** err_msg, casadi::Function* x0)"
-// call: "casadi::SXFunction(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__8(std::string ** err_msg, casadi::Function* x0);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__8(std::string ** err_msg, casadi::Function* x0){
-    try {
-        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
-
-        return new casadi::SXFunction(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__9"
-// protoArgs: "(std::string ** err_msg, casadi::MXFunction* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__9(std::string ** err_msg, casadi::MXFunction* x0)"
-// call: "casadi::SXFunction(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MXFunction")))]
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__9(std::string ** err_msg, casadi::MXFunction* x0);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__9(std::string ** err_msg, casadi::MXFunction* x0){
-    try {
-        casadi::MXFunction& x0_ = Marshaling<casadi::MXFunction&,casadi::MXFunction*>::marshal(x0);
-
-        return new casadi::SXFunction(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction"
-// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__10"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
-// cWrapperRetType: "casadi::SXFunction*"
-// proto: "casadi::SXFunction*\n    casadi__SXFunction__CONSTRUCTOR__10(std::string ** err_msg)"
-// call: "casadi::SXFunction()"
-// params: []
-extern "C"
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__10(std::string ** err_msg);
-casadi::SXFunction*
-    casadi__SXFunction__CONSTRUCTOR__10(std::string ** err_msg){
-    try {
-
-        return new casadi::SXFunction();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "clearSymbolic" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::clearSymbolic"
-// cWrapperName: "casadi__SXFunction__clearSymbolic"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SXFunction__clearSymbolic(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->clearSymbolic()"
-// params: []
-extern "C"
-void
-    casadi__SXFunction__clearSymbolic(std::string ** err_msg, casadi::SXFunction* obj);
-void
-    casadi__SXFunction__clearSymbolic(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        obj->clearSymbolic();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "countNodes" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::countNodes"
-// cWrapperName: "casadi__SXFunction__countNodes"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SXFunction__countNodes(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->countNodes()"
-// params: []
-extern "C"
-int
-    casadi__SXFunction__countNodes(std::string ** err_msg, casadi::SXFunction* obj);
-int
-    casadi__SXFunction__countNodes(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        int ret = obj->countNodes();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAlgorithmSize" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::getAlgorithmSize"
-// cWrapperName: "casadi__SXFunction__getAlgorithmSize"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SXFunction__getAlgorithmSize(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->getAlgorithmSize()"
-// params: []
-extern "C"
-int
-    casadi__SXFunction__getAlgorithmSize(std::string ** err_msg, casadi::SXFunction* obj);
-int
-    casadi__SXFunction__getAlgorithmSize(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        int ret = obj->getAlgorithmSize();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAtomicInput" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::getAtomicInput"
-// cWrapperName: "casadi__SXFunction__getAtomicInput"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__SXFunction__getAtomicInput(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->getAtomicInput(x0_)"
-// params: [CInt]
-extern "C"
-std::pair< int, int >*
-    casadi__SXFunction__getAtomicInput(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-std::pair< int, int >*
-    casadi__SXFunction__getAtomicInput(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::pair< int, int > ret = obj->getAtomicInput(x0_);
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAtomicInputReal" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::getAtomicInputReal"
-// cWrapperName: "casadi__SXFunction__getAtomicInputReal"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: CDouble
-// cWrapperRetType: "double"
-// proto: "double\n    casadi__SXFunction__getAtomicInputReal(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->getAtomicInputReal(x0_)"
-// params: [CInt]
-extern "C"
-double
-    casadi__SXFunction__getAtomicInputReal(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-double
-    casadi__SXFunction__getAtomicInputReal(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        double ret = obj->getAtomicInputReal(x0_);
-        return WrapReturn< double, double >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAtomicOperation" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::getAtomicOperation"
-// cWrapperName: "casadi__SXFunction__getAtomicOperation"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SXFunction__getAtomicOperation(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->getAtomicOperation(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__SXFunction__getAtomicOperation(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-int
-    casadi__SXFunction__getAtomicOperation(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->getAtomicOperation(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAtomicOutput" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::getAtomicOutput"
-// cWrapperName: "casadi__SXFunction__getAtomicOutput"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SXFunction__getAtomicOutput(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->getAtomicOutput(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__SXFunction__getAtomicOutput(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-int
-    casadi__SXFunction__getAtomicOutput(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->getAtomicOutput(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getFree" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::getFree"
-// cWrapperName: "casadi__SXFunction__getFree"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__getFree(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->getFree()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SXFunction__getFree(std::string ** err_msg, casadi::SXFunction* obj);
-casadi::SX*
-    casadi__SXFunction__getFree(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        casadi::SX ret = obj->getFree();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getWorkSize" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::getWorkSize"
-// cWrapperName: "casadi__SXFunction__getWorkSize"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SXFunction__getWorkSize(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->getWorkSize()"
-// params: []
-extern "C"
-int
-    casadi__SXFunction__getWorkSize(std::string ** err_msg, casadi::SXFunction* obj);
-int
-    casadi__SXFunction__getWorkSize(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        int ret = obj->getWorkSize();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::grad"
-// cWrapperName: "casadi__SXFunction__grad__0"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__grad__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__grad__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__grad__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::grad"
-// cWrapperName: "casadi__SXFunction__grad__1"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__grad__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__grad__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__grad__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::grad"
-// cWrapperName: "casadi__SXFunction__grad__2"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__grad__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// call: "obj->grad(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__grad__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
-casadi::SX*
-    casadi__SXFunction__grad__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SX ret = obj->grad(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::grad"
-// cWrapperName: "casadi__SXFunction__grad__3"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__grad__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__grad__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
-casadi::SX*
-    casadi__SXFunction__grad__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::grad"
-// cWrapperName: "casadi__SXFunction__grad__4"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__grad__4(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->grad()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SXFunction__grad__4(std::string ** err_msg, casadi::SXFunction* obj);
-casadi::SX*
-    casadi__SXFunction__grad__4(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        casadi::SX ret = obj->grad();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::grad"
-// cWrapperName: "casadi__SXFunction__grad__5"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__grad__5(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->grad(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__grad__5(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-casadi::SX*
-    casadi__SXFunction__grad__5(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = obj->grad(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "grad" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::grad"
-// cWrapperName: "casadi__SXFunction__grad__6"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__grad__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// call: "obj->grad(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__grad__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
-casadi::SX*
-    casadi__SXFunction__grad__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->grad(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hess" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::hess"
-// cWrapperName: "casadi__SXFunction__hess__0"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__hess__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// call: "obj->hess(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__hess__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__hess__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->hess(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hess" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::hess"
-// cWrapperName: "casadi__SXFunction__hess__1"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__hess__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// call: "obj->hess(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__hess__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__hess__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->hess(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hess" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::hess"
-// cWrapperName: "casadi__SXFunction__hess__2"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__hess__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// call: "obj->hess(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__hess__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
-casadi::SX*
-    casadi__SXFunction__hess__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SX ret = obj->hess(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hess" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::hess"
-// cWrapperName: "casadi__SXFunction__hess__3"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__hess__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// call: "obj->hess(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__hess__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
-casadi::SX*
-    casadi__SXFunction__hess__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->hess(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hess" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::hess"
-// cWrapperName: "casadi__SXFunction__hess__4"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__hess__4(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->hess()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SXFunction__hess__4(std::string ** err_msg, casadi::SXFunction* obj);
-casadi::SX*
-    casadi__SXFunction__hess__4(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        casadi::SX ret = obj->hess();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hess" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::hess"
-// cWrapperName: "casadi__SXFunction__hess__5"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__hess__5(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->hess(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__hess__5(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-casadi::SX*
-    casadi__SXFunction__hess__5(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = obj->hess(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hess" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::hess"
-// cWrapperName: "casadi__SXFunction__hess__6"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__hess__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// call: "obj->hess(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__hess__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
-casadi::SX*
-    casadi__SXFunction__hess__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->hess(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputExpr" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::inputExpr"
-// cWrapperName: "casadi__SXFunction__inputExpr__0"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__SXFunction__inputExpr__0(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->inputExpr()"
-// params: []
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__SXFunction__inputExpr__0(std::string ** err_msg, casadi::SXFunction* obj);
-std::vector< casadi::SX* >*
-    casadi__SXFunction__inputExpr__0(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        std::vector< casadi::SX > ret = obj->inputExpr();
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputExpr" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::inputExpr"
-// cWrapperName: "casadi__SXFunction__inputExpr__1"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__inputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// call: "obj->inputExpr(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__inputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
-casadi::SX*
-    casadi__SXFunction__inputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SX ret = obj->inputExpr(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "inputExpr" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::inputExpr"
-// cWrapperName: "casadi__SXFunction__inputExpr__2"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__inputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->inputExpr(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__inputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-casadi::SX*
-    casadi__SXFunction__inputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = obj->inputExpr(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__0"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__jac__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__1"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2);
-casadi::SX*
-    casadi__SXFunction__jac__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__2"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3);
-casadi::SX*
-    casadi__SXFunction__jac__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__3"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__3(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__3(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__jac__3(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__4"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__4(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const StdString),CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__4(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2);
-casadi::SX*
-    casadi__SXFunction__jac__4(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__5"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__5(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [CInt,Ref (Const StdString),CBool,CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__5(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3);
-casadi::SX*
-    casadi__SXFunction__jac__5(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__6"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__6(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// call: "obj->jac(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__6(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
-casadi::SX*
-    casadi__SXFunction__jac__6(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SX ret = obj->jac(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__7"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__7(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__7(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
-casadi::SX*
-    casadi__SXFunction__jac__7(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__8"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__8(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),CInt,CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__8(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2);
-casadi::SX*
-    casadi__SXFunction__jac__8(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__9"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__9(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),CInt,CBool,CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__9(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3);
-casadi::SX*
-    casadi__SXFunction__jac__9(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__10"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__10(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->jac()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__10(std::string ** err_msg, casadi::SXFunction* obj);
-casadi::SX*
-    casadi__SXFunction__jac__10(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        casadi::SX ret = obj->jac();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__11"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__11(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->jac(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__11(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-casadi::SX*
-    casadi__SXFunction__jac__11(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = obj->jac(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__12"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__12(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// call: "obj->jac(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__12(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
-casadi::SX*
-    casadi__SXFunction__jac__12(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->jac(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__13"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__13(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2)"
-// call: "obj->jac(x0_, x1_, x2_)"
-// params: [CInt,CInt,CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__13(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2);
-casadi::SX*
-    casadi__SXFunction__jac__13(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "jac" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::jac"
-// cWrapperName: "casadi__SXFunction__jac__14"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__jac__14(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3)"
-// call: "obj->jac(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,CBool,CBool]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__jac__14(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3);
-casadi::SX*
-    casadi__SXFunction__jac__14(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::SX ret = obj->jac(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputExpr" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::outputExpr"
-// cWrapperName: "casadi__SXFunction__outputExpr__0"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
-// cWrapperRetType: "std::vector< casadi::SX* >*"
-// proto: "std::vector< casadi::SX* >*\n    casadi__SXFunction__outputExpr__0(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->outputExpr()"
-// params: []
-extern "C"
-std::vector< casadi::SX* >*
-    casadi__SXFunction__outputExpr__0(std::string ** err_msg, casadi::SXFunction* obj);
-std::vector< casadi::SX* >*
-    casadi__SXFunction__outputExpr__0(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        std::vector< casadi::SX > ret = obj->outputExpr();
-        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputExpr" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::outputExpr"
-// cWrapperName: "casadi__SXFunction__outputExpr__1"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__outputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// call: "obj->outputExpr(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__outputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
-casadi::SX*
-    casadi__SXFunction__outputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SX ret = obj->outputExpr(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "outputExpr" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::outputExpr"
-// cWrapperName: "casadi__SXFunction__outputExpr__2"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__outputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->outputExpr(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__outputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-casadi::SX*
-    casadi__SXFunction__outputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = obj->outputExpr(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::tang"
-// cWrapperName: "casadi__SXFunction__tang__0"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__tang__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__tang__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__tang__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::tang"
-// cWrapperName: "casadi__SXFunction__tang__1"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__tang__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [CInt,Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__tang__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
-casadi::SX*
-    casadi__SXFunction__tang__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        casadi::SX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::tang"
-// cWrapperName: "casadi__SXFunction__tang__2"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__tang__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
-// call: "obj->tang(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__tang__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
-casadi::SX*
-    casadi__SXFunction__tang__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SX ret = obj->tang(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::tang"
-// cWrapperName: "casadi__SXFunction__tang__3"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__tang__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [Ref (Const StdString),CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__tang__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
-casadi::SX*
-    casadi__SXFunction__tang__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::tang"
-// cWrapperName: "casadi__SXFunction__tang__4"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__tang__4(std::string ** err_msg, casadi::SXFunction* obj)"
-// call: "obj->tang()"
-// params: []
-extern "C"
-casadi::SX*
-    casadi__SXFunction__tang__4(std::string ** err_msg, casadi::SXFunction* obj);
-casadi::SX*
-    casadi__SXFunction__tang__4(std::string ** err_msg, casadi::SXFunction* obj){
-    try {
-
-        casadi::SX ret = obj->tang();
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::tang"
-// cWrapperName: "casadi__SXFunction__tang__5"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__tang__5(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
-// call: "obj->tang(x0_)"
-// params: [CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__tang__5(std::string ** err_msg, casadi::SXFunction* obj, int x0);
-casadi::SX*
-    casadi__SXFunction__tang__5(std::string ** err_msg, casadi::SXFunction* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::SX ret = obj->tang(x0_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "tang" ===============
-// class: "casadi::SXFunction"
-// cppName: "casadi::SXFunction::tang"
-// cWrapperName: "casadi__SXFunction__tang__6"
-// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SX")
-// cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX*\n    casadi__SXFunction__tang__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
-// call: "obj->tang(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::SX*
-    casadi__SXFunction__tang__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
-casadi::SX*
-    casadi__SXFunction__tang__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::SX ret = obj->tang(x0_, x1_);
-        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SdpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SdpSolver")
-extern "C"
-void delete_casadi__SdpSolver(casadi::SdpSolver* obj);
-void delete_casadi__SdpSolver(casadi::SdpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SdpSolver"
-// cppName: "casadi::SdpSolver"
-// cWrapperName: "casadi__SdpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SdpSolver")
-// cWrapperRetType: "casadi::SdpSolver*"
-// proto: "casadi::SdpSolver*\n    casadi__SdpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::SdpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::SdpSolver*
-    casadi__SdpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::SdpSolver*
-    casadi__SdpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::SdpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SdpSolver"
-// cppName: "casadi::SdpSolver"
-// cWrapperName: "casadi__SdpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SdpSolver")
-// cWrapperRetType: "casadi::SdpSolver*"
-// proto: "casadi::SdpSolver*\n    casadi__SdpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::SdpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::SdpSolver*
-    casadi__SdpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::SdpSolver*
-    casadi__SdpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::SdpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SdpSolver"
-// cppName: "casadi::SdpSolver"
-// cWrapperName: "casadi__SdpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SdpSolver")
-// cWrapperRetType: "casadi::SdpSolver*"
-// proto: "casadi::SdpSolver*\n    casadi__SdpSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::SdpSolver()"
-// params: []
-extern "C"
-casadi::SdpSolver*
-    casadi__SdpSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::SdpSolver*
-    casadi__SdpSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::SdpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::SdpSolver"
-// cppName: "casadi::SdpSolver::doc"
-// cWrapperName: "casadi__SdpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SdpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SdpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__SdpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__SdpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::SdpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::SdpSolver"
-// cppName: "casadi::SdpSolver::hasPlugin"
-// cWrapperName: "casadi__SdpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SdpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SdpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__SdpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__SdpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::SdpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::SdpSolver"
-// cppName: "casadi::SdpSolver::loadPlugin"
-// cWrapperName: "casadi__SdpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SdpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SdpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__SdpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__SdpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SdpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SdqpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SdqpSolver")
-extern "C"
-void delete_casadi__SdqpSolver(casadi::SdqpSolver* obj);
-void delete_casadi__SdqpSolver(casadi::SdqpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SdqpSolver"
-// cppName: "casadi::SdqpSolver"
-// cWrapperName: "casadi__SdqpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SdqpSolver")
-// cWrapperRetType: "casadi::SdqpSolver*"
-// proto: "casadi::SdqpSolver*\n    casadi__SdqpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::SdqpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::SdqpSolver*
-    casadi__SdqpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::SdqpSolver*
-    casadi__SdqpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::SdqpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SdqpSolver"
-// cppName: "casadi::SdqpSolver"
-// cWrapperName: "casadi__SdqpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SdqpSolver")
-// cWrapperRetType: "casadi::SdqpSolver*"
-// proto: "casadi::SdqpSolver*\n    casadi__SdqpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::SdqpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::SdqpSolver*
-    casadi__SdqpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::SdqpSolver*
-    casadi__SdqpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::SdqpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SdqpSolver"
-// cppName: "casadi::SdqpSolver"
-// cWrapperName: "casadi__SdqpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SdqpSolver")
-// cWrapperRetType: "casadi::SdqpSolver*"
-// proto: "casadi::SdqpSolver*\n    casadi__SdqpSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::SdqpSolver()"
-// params: []
-extern "C"
-casadi::SdqpSolver*
-    casadi__SdqpSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::SdqpSolver*
-    casadi__SdqpSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::SdqpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::SdqpSolver"
-// cppName: "casadi::SdqpSolver::doc"
-// cWrapperName: "casadi__SdqpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SdqpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SdqpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__SdqpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__SdqpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::SdqpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::SdqpSolver"
-// cppName: "casadi::SdqpSolver::hasPlugin"
-// cWrapperName: "casadi__SdqpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SdqpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SdqpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__SdqpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__SdqpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::SdqpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::SdqpSolver"
-// cppName: "casadi::SdqpSolver::loadPlugin"
-// cWrapperName: "casadi__SdqpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SdqpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SdqpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__SdqpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__SdqpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SdqpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SharedObject")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SharedObject")
-extern "C"
-void delete_casadi__SharedObject(casadi::SharedObject* obj);
-void delete_casadi__SharedObject(casadi::SharedObject* obj){
-    delete obj;
-}
-
-// ================== Normal method: "__hash__" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::__hash__"
-// cWrapperName: "casadi__SharedObject____hash__"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__SharedObject____hash__(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->__hash__()"
-// params: []
-extern "C"
-size_t
-    casadi__SharedObject____hash__(std::string ** err_msg, casadi::SharedObject* obj);
-size_t
-    casadi__SharedObject____hash__(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        size_t ret = obj->__hash__();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "assertInit" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::assertInit"
-// cWrapperName: "casadi__SharedObject__assertInit"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SharedObject__assertInit(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->assertInit()"
-// params: []
-extern "C"
-void
-    casadi__SharedObject__assertInit(std::string ** err_msg, casadi::SharedObject* obj);
-void
-    casadi__SharedObject__assertInit(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        obj->assertInit();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "init" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::init"
-// cWrapperName: "casadi__SharedObject__init__0"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SharedObject__init__0(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->init()"
-// params: []
-extern "C"
-void
-    casadi__SharedObject__init__0(std::string ** err_msg, casadi::SharedObject* obj);
-void
-    casadi__SharedObject__init__0(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        obj->init();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "init" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::init"
-// cWrapperName: "casadi__SharedObject__init__1"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SharedObject__init__1(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
-// call: "obj->init(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__SharedObject__init__1(std::string ** err_msg, casadi::SharedObject* obj, int x0);
-void
-    casadi__SharedObject__init__1(std::string ** err_msg, casadi::SharedObject* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->init(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "isInit" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::isInit"
-// cWrapperName: "casadi__SharedObject__isInit"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SharedObject__isInit(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->isInit()"
-// params: []
-extern "C"
-int
-    casadi__SharedObject__isInit(std::string ** err_msg, casadi::SharedObject* obj);
-int
-    casadi__SharedObject__isInit(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        bool ret = obj->isInit();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isNull" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::isNull"
-// cWrapperName: "casadi__SharedObject__isNull"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SharedObject__isNull(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->isNull()"
-// params: []
-extern "C"
-int
-    casadi__SharedObject__isNull(std::string ** err_msg, casadi::SharedObject* obj);
-int
-    casadi__SharedObject__isNull(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        bool ret = obj->isNull();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "makeUnique" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::makeUnique"
-// cWrapperName: "casadi__SharedObject__makeUnique__0"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SharedObject__makeUnique__0(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->makeUnique()"
-// params: []
-extern "C"
-void
-    casadi__SharedObject__makeUnique__0(std::string ** err_msg, casadi::SharedObject* obj);
-void
-    casadi__SharedObject__makeUnique__0(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        obj->makeUnique();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "makeUnique" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::makeUnique"
-// cWrapperName: "casadi__SharedObject__makeUnique__1"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SharedObject__makeUnique__1(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
-// call: "obj->makeUnique(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__SharedObject__makeUnique__1(std::string ** err_msg, casadi::SharedObject* obj, int x0);
-void
-    casadi__SharedObject__makeUnique__1(std::string ** err_msg, casadi::SharedObject* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->makeUnique(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "printPtr" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::printPtr"
-// cWrapperName: "casadi__SharedObject__printPtr"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->printPtr()"
-// params: []
-extern "C"
-void
-    casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj);
-void
-    casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        obj->printPtr();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::getRepresentation"
-// cWrapperName: "casadi__SharedObject__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj);
-std::string*
-    casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::SharedObject"
-// cppName: "casadi::SharedObject::getDescription"
-// cWrapperName: "casadi__SharedObject__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj);
-std::string*
-    casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Simulator")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Simulator")
-extern "C"
-void delete_casadi__Simulator(casadi::Simulator* obj);
-void delete_casadi__Simulator(casadi::Simulator* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Simulator"
-// cppName: "casadi::Simulator"
-// cWrapperName: "casadi__Simulator__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
-// cWrapperRetType: "casadi::Simulator*"
-// proto: "casadi::Simulator*\n    casadi__Simulator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2)"
-// call: "casadi::Simulator(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2);
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Integrator& x1_ = Marshaling<casadi::Integrator&,casadi::Integrator*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-
-        return new casadi::Simulator(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Simulator"
-// cppName: "casadi::Simulator"
-// cWrapperName: "casadi__Simulator__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
-// cWrapperRetType: "casadi::Simulator*"
-// proto: "casadi::Simulator*\n    casadi__Simulator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::Simulator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::DMatrix* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Integrator& x1_ = Marshaling<casadi::Integrator&,casadi::Integrator*>::marshal(x1);
-        casadi::DMatrix& x2_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::Simulator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Simulator"
-// cppName: "casadi::Simulator"
-// cWrapperName: "casadi__Simulator__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
-// cWrapperRetType: "casadi::Simulator*"
-// proto: "casadi::Simulator*\n    casadi__Simulator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3)"
-// call: "casadi::Simulator(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3);
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Integrator& x1_ = Marshaling<casadi::Integrator&,casadi::Integrator*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        casadi::DMatrix& x3_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x3);
-
-        return new casadi::Simulator(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Simulator"
-// cppName: "casadi::Simulator"
-// cWrapperName: "casadi__Simulator__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
-// cWrapperRetType: "casadi::Simulator*"
-// proto: "casadi::Simulator*\n    casadi__Simulator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4)"
-// call: "casadi::Simulator(x0_, x1_, x2_, x3_, x4_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4);
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, casadi::Integrator* x1, casadi::Function* x2, casadi::DMatrix* x3, std::map< std::string, casadi::GenericType* >* x4){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Integrator& x1_ = Marshaling<casadi::Integrator&,casadi::Integrator*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        casadi::DMatrix& x3_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x3);
-        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
-
-        return new casadi::Simulator(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Simulator"
-// cppName: "casadi::Simulator"
-// cWrapperName: "casadi__Simulator__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
-// cWrapperRetType: "casadi::Simulator*"
-// proto: "casadi::Simulator*\n    casadi__Simulator__CONSTRUCTOR__4(std::string ** err_msg)"
-// call: "casadi::Simulator()"
-// params: []
-extern "C"
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__4(std::string ** err_msg);
-casadi::Simulator*
-    casadi__Simulator__CONSTRUCTOR__4(std::string ** err_msg){
-    try {
-
-        return new casadi::Simulator();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Slice")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Slice")
-extern "C"
-void delete_casadi__Slice(casadi::Slice* obj);
-void delete_casadi__Slice(casadi::Slice* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1)"
-// call: "casadi::Slice(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (UserType (Namespace ["casadi"]) (Name "Slice"))]
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        casadi::Slice& x1_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x1);
-
-        return new casadi::Slice(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::Slice(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        return new casadi::Slice(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0, int x1)"
-// call: "casadi::Slice(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0, int x1);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        return new casadi::Slice(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Slice(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        return new casadi::Slice(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg, int x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg, int x0, int x1, int x2)"
-// call: "casadi::Slice(x0_, x1_, x2_)"
-// params: [CInt,CInt,CInt]
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg, int x0, int x1, int x2);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg, int x0, int x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-
-        return new casadi::Slice(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__5"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__5(std::string ** err_msg, int x0)"
-// call: "casadi::Slice(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__5(std::string ** err_msg, int x0);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__5(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        return new casadi::Slice(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__6"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Slice(x0_, x1_)"
-// params: [CInt,CBool]
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        return new casadi::Slice(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice"
-// cWrapperName: "casadi__Slice__CONSTRUCTOR__7"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
-// cWrapperRetType: "casadi::Slice*"
-// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__7(std::string ** err_msg)"
-// call: "casadi::Slice()"
-// params: []
-extern "C"
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__7(std::string ** err_msg);
-casadi::Slice*
-    casadi__Slice__CONSTRUCTOR__7(std::string ** err_msg){
-    try {
-
-        return new casadi::Slice();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAll" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::getAll"
-// cWrapperName: "casadi__Slice__getAll__0"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Slice__getAll__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1)"
-// call: "obj->getAll(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
-extern "C"
-std::vector< int >*
-    casadi__Slice__getAll__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1);
-std::vector< int >*
-    casadi__Slice__getAll__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1){
-    try {
-        casadi::Slice& x0_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        std::vector< int > ret = obj->getAll(x0_, x1_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAll" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::getAll"
-// cWrapperName: "casadi__Slice__getAll__1"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Slice__getAll__1(std::string ** err_msg, casadi::Slice* obj, int x0)"
-// call: "obj->getAll(x0_)"
-// params: [CInt]
-extern "C"
-std::vector< int >*
-    casadi__Slice__getAll__1(std::string ** err_msg, casadi::Slice* obj, int x0);
-std::vector< int >*
-    casadi__Slice__getAll__1(std::string ** err_msg, casadi::Slice* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        std::vector< int > ret = obj->getAll(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getAll" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::getAll"
-// cWrapperName: "casadi__Slice__getAll__2"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Slice__getAll__2(std::string ** err_msg, casadi::Slice* obj, int x0, int x1)"
-// call: "obj->getAll(x0_, x1_)"
-// params: [CInt,CBool]
-extern "C"
-std::vector< int >*
-    casadi__Slice__getAll__2(std::string ** err_msg, casadi::Slice* obj, int x0, int x1);
-std::vector< int >*
-    casadi__Slice__getAll__2(std::string ** err_msg, casadi::Slice* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< int > ret = obj->getAll(x0_, x1_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "isSlice" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::isSlice"
-// cWrapperName: "casadi__Slice__isSlice__0"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Slice__isSlice__0(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::Slice::isSlice(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-int
-    casadi__Slice__isSlice__0(std::string ** err_msg, std::vector< int >* x0);
-int
-    casadi__Slice__isSlice__0(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        bool ret = casadi::Slice::isSlice(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "isSlice" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::isSlice"
-// cWrapperName: "casadi__Slice__isSlice__1"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Slice__isSlice__1(std::string ** err_msg, std::vector< int >* x0, int x1)"
-// call: "casadi::Slice::isSlice(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-int
-    casadi__Slice__isSlice__1(std::string ** err_msg, std::vector< int >* x0, int x1);
-int
-    casadi__Slice__isSlice__1(std::string ** err_msg, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        bool ret = casadi::Slice::isSlice(x0_, x1_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "isSlice2" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::isSlice2"
-// cWrapperName: "casadi__Slice__isSlice2"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Slice__isSlice2(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::Slice::isSlice2(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-int
-    casadi__Slice__isSlice2(std::string ** err_msg, std::vector< int >* x0);
-int
-    casadi__Slice__isSlice2(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        bool ret = casadi::Slice::isSlice2(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::isscalar"
-// cWrapperName: "casadi__Slice__isscalar"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Slice__isscalar(std::string ** err_msg, casadi::Slice* obj, int x0)"
-// call: "obj->isscalar(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__Slice__isscalar(std::string ** err_msg, casadi::Slice* obj, int x0);
-int
-    casadi__Slice__isscalar(std::string ** err_msg, casadi::Slice* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        bool ret = obj->isscalar(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator !=" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::operator !="
-// cWrapperName: "casadi__Slice__operator_nequals"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Slice__operator_nequals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
-// call: "obj->operator !=(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-int
-    casadi__Slice__operator_nequals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0);
-int
-    casadi__Slice__operator_nequals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0){
-    try {
-        casadi::Slice& x0_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x0);
-
-        bool ret = obj->operator !=(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ==" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::operator =="
-// cWrapperName: "casadi__Slice__operator_equals"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Slice__operator_equals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
-// call: "obj->operator ==(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
-extern "C"
-int
-    casadi__Slice__operator_equals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0);
-int
-    casadi__Slice__operator_equals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0){
-    try {
-        casadi::Slice& x0_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x0);
-
-        bool ret = obj->operator ==(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "toScalar" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::toScalar"
-// cWrapperName: "casadi__Slice__toScalar"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Slice__toScalar(std::string ** err_msg, casadi::Slice* obj, int x0)"
-// call: "obj->toScalar(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__Slice__toScalar(std::string ** err_msg, casadi::Slice* obj, int x0);
-int
-    casadi__Slice__toScalar(std::string ** err_msg, casadi::Slice* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->toScalar(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::getRepresentation"
-// cWrapperName: "casadi__Slice__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj);
-std::string*
-    casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::Slice"
-// cppName: "casadi::Slice::getDescription"
-// cWrapperName: "casadi__Slice__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::Slice* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj);
-std::string*
-    casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SocpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SocpSolver")
-extern "C"
-void delete_casadi__SocpSolver(casadi::SocpSolver* obj);
-void delete_casadi__SocpSolver(casadi::SocpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SocpSolver"
-// cppName: "casadi::SocpSolver"
-// cWrapperName: "casadi__SocpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SocpSolver")
-// cWrapperRetType: "casadi::SocpSolver*"
-// proto: "casadi::SocpSolver*\n    casadi__SocpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::SocpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::SocpSolver*
-    casadi__SocpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::SocpSolver*
-    casadi__SocpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::SocpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SocpSolver"
-// cppName: "casadi::SocpSolver"
-// cWrapperName: "casadi__SocpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "SocpSolver")
-// cWrapperRetType: "casadi::SocpSolver*"
-// proto: "casadi::SocpSolver*\n    casadi__SocpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::SocpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::SocpSolver*
-    casadi__SocpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::SocpSolver*
-    casadi__SocpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::SocpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::SocpSolver"
-// cppName: "casadi::SocpSolver"
-// cWrapperName: "casadi__SocpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "SocpSolver")
-// cWrapperRetType: "casadi::SocpSolver*"
-// proto: "casadi::SocpSolver*\n    casadi__SocpSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::SocpSolver()"
-// params: []
-extern "C"
-casadi::SocpSolver*
-    casadi__SocpSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::SocpSolver*
-    casadi__SocpSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::SocpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::SocpSolver"
-// cppName: "casadi::SocpSolver::doc"
-// cWrapperName: "casadi__SocpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__SocpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SocpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__SocpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__SocpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::SocpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::SocpSolver"
-// cppName: "casadi::SocpSolver::hasPlugin"
-// cWrapperName: "casadi__SocpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__SocpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SocpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__SocpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__SocpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::SocpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::SocpSolver"
-// cppName: "casadi::SocpSolver::loadPlugin"
-// cWrapperName: "casadi__SocpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__SocpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::SocpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__SocpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__SocpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::SocpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Sparsity")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Sparsity")
-extern "C"
-void delete_casadi__Sparsity(casadi::Sparsity* obj);
-void delete_casadi__Sparsity(casadi::Sparsity* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity"
-// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "casadi::Sparsity(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        return new casadi::Sparsity(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity"
-// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Sparsity(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        return new casadi::Sparsity(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity"
-// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::Sparsity()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::Sparsity();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity"
-// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__3(std::string ** err_msg, int x0)"
-// call: "casadi::Sparsity(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__3(std::string ** err_msg, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__CONSTRUCTOR__3(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        return new casadi::Sparsity(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "T" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::T"
-// cWrapperName: "casadi__Sparsity__T"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__T(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->T()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__T(std::string ** err_msg, casadi::Sparsity* obj);
-casadi::Sparsity*
-    casadi__Sparsity__T(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        casadi::Sparsity ret = obj->T();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "addNZ" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::addNZ"
-// cWrapperName: "casadi__Sparsity__addNZ"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__addNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// call: "obj->addNZ(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-int
-    casadi__Sparsity__addNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
-int
-    casadi__Sparsity__addNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        int ret = obj->addNZ(x0_, x1_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "append" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::append"
-// cWrapperName: "casadi__Sparsity__append"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->append(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-void
-    casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        obj->append(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "appendColumns" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::appendColumns"
-// cWrapperName: "casadi__Sparsity__appendColumns"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->appendColumns(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-void
-    casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-void
-    casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        obj->appendColumns(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "band" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::band"
-// cWrapperName: "casadi__Sparsity__band"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__band(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Sparsity::band(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__band(std::string ** err_msg, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__band(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = casadi::Sparsity::band(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "banded" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::banded"
-// cWrapperName: "casadi__Sparsity__banded"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Sparsity::banded(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = casadi::Sparsity::banded(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "bandwidthL" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::bandwidthL"
-// cWrapperName: "casadi__Sparsity__bandwidthL"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__bandwidthL(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->bandwidthL()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__bandwidthL(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__bandwidthL(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->bandwidthL();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "bandwidthU" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::bandwidthU"
-// cWrapperName: "casadi__Sparsity__bandwidthU"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__bandwidthU(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->bandwidthU()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__bandwidthU(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__bandwidthU(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->bandwidthU();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "clearCache" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::clearCache"
-// cWrapperName: "casadi__Sparsity__clearCache"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__clearCache(std::string ** err_msg)"
-// call: "casadi::Sparsity::clearCache()"
-// params: []
-extern "C"
-void
-    casadi__Sparsity__clearCache(std::string ** err_msg);
-void
-    casadi__Sparsity__clearCache(std::string ** err_msg){
-    try {
-
-        casadi::Sparsity::clearCache();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "colind" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::colind"
-// cWrapperName: "casadi__Sparsity__colind"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__colind(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->colind(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__Sparsity__colind(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-int
-    casadi__Sparsity__colind(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->colind(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "compress" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::compress"
-// cWrapperName: "casadi__Sparsity__compress"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->compress()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->compress();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "compressed" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::compressed"
-// cWrapperName: "casadi__Sparsity__compressed"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0)"
-// call: "casadi::Sparsity::compressed(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::compressed(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "dense" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::dense"
-// cWrapperName: "casadi__Sparsity__dense__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__dense__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::Sparsity::dense(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__dense__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__dense__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::dense(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "dense" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::dense"
-// cWrapperName: "casadi__Sparsity__dense__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__dense__1(std::string ** err_msg, int x0)"
-// call: "casadi::Sparsity::dense(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__dense__1(std::string ** err_msg, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__dense__1(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::dense(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "dense" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::dense"
-// cWrapperName: "casadi__Sparsity__dense__2"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__dense__2(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Sparsity::dense(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__dense__2(std::string ** err_msg, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__dense__2(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = casadi::Sparsity::dense(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "depthFirstSearch" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::depthFirstSearch"
-// cWrapperName: "casadi__Sparsity__depthFirstSearch"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__depthFirstSearch(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
-// call: "obj->depthFirstSearch(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [CInt,CInt,Ref (StdVec CInt),Ref (StdVec CInt),Ref (Const (StdVec CInt)),Ref (StdVec CBool)]
-extern "C"
-int
-    casadi__Sparsity__depthFirstSearch(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5);
-int
-    casadi__Sparsity__depthFirstSearch(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-        std::vector< bool > x5_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x5);
-
-        int ret = obj->depthFirstSearch(x0_, x1_, x2_, x3_, x4_, x5_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "diag" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::diag"
-// cWrapperName: "casadi__Sparsity__diag__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__diag__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::Sparsity::diag(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__diag__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__diag__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::diag(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "diag" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::diag"
-// cWrapperName: "casadi__Sparsity__diag__1"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__diag__1(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Sparsity::diag(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__diag__1(std::string ** err_msg, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__diag__1(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = casadi::Sparsity::diag(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "diag" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::diag"
-// cWrapperName: "casadi__Sparsity__diag__2"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__diag__2(std::string ** err_msg, int x0)"
-// call: "casadi::Sparsity::diag(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__diag__2(std::string ** err_msg, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__diag__2(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::diag(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "dimString" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::dimString"
-// cWrapperName: "casadi__Sparsity__dimString"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Sparsity__dimString(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->dimString()"
-// params: []
-extern "C"
-std::string*
-    casadi__Sparsity__dimString(std::string ** err_msg, casadi::Sparsity* obj);
-std::string*
-    casadi__Sparsity__dimString(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::string ret = obj->dimString();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "dulmageMendelsohn" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::dulmageMendelsohn"
-// cWrapperName: "casadi__Sparsity__dulmageMendelsohn__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__dulmageMendelsohn__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
-// call: "obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt)]
-extern "C"
-int
-    casadi__Sparsity__dulmageMendelsohn__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5);
-int
-    casadi__Sparsity__dulmageMendelsohn__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-        std::vector< int > x5_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x5);
-
-        int ret = obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "dulmageMendelsohn" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::dulmageMendelsohn"
-// cWrapperName: "casadi__Sparsity__dulmageMendelsohn__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__dulmageMendelsohn__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6)"
-// call: "obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
-// params: [Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),CInt]
-extern "C"
-int
-    casadi__Sparsity__dulmageMendelsohn__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6);
-int
-    casadi__Sparsity__dulmageMendelsohn__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-        std::vector< int > x5_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x5);
-        int x6_ = Marshaling<int,int>::marshal(x6);
-
-        int ret = obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "eliminationTree" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::eliminationTree"
-// cWrapperName: "casadi__Sparsity__eliminationTree__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__eliminationTree__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->eliminationTree()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__eliminationTree__0(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__eliminationTree__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->eliminationTree();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "eliminationTree" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::eliminationTree"
-// cWrapperName: "casadi__Sparsity__eliminationTree__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__eliminationTree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->eliminationTree(x0_)"
-// params: [CBool]
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__eliminationTree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-std::vector< int >*
-    casadi__Sparsity__eliminationTree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        std::vector< int > ret = obj->eliminationTree(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::enlarge"
-// cWrapperName: "casadi__Sparsity__enlarge__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__enlarge__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__Sparsity__enlarge__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-void
-    casadi__Sparsity__enlarge__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        obj->enlarge(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlarge" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::enlarge"
-// cWrapperName: "casadi__Sparsity__enlarge__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__enlarge__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
-// call: "obj->enlarge(x0_, x1_, x2_, x3_, x4_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__Sparsity__enlarge__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
-void
-    casadi__Sparsity__enlarge__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        bool x4_ = Marshaling<bool,int>::marshal(x4);
-
-        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlargeColumns" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::enlargeColumns"
-// cWrapperName: "casadi__Sparsity__enlargeColumns__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__enlargeColumns__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
-// call: "obj->enlargeColumns(x0_, x1_)"
-// params: [CInt,Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__Sparsity__enlargeColumns__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1);
-void
-    casadi__Sparsity__enlargeColumns__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->enlargeColumns(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlargeColumns" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::enlargeColumns"
-// cWrapperName: "casadi__Sparsity__enlargeColumns__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__enlargeColumns__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
-// call: "obj->enlargeColumns(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__Sparsity__enlargeColumns__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2);
-void
-    casadi__Sparsity__enlargeColumns__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->enlargeColumns(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlargeRows" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::enlargeRows"
-// cWrapperName: "casadi__Sparsity__enlargeRows__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__enlargeRows__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
-// call: "obj->enlargeRows(x0_, x1_)"
-// params: [CInt,Ref (Const (StdVec CInt))]
-extern "C"
-void
-    casadi__Sparsity__enlargeRows__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1);
-void
-    casadi__Sparsity__enlargeRows__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->enlargeRows(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "enlargeRows" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::enlargeRows"
-// cWrapperName: "casadi__Sparsity__enlargeRows__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__enlargeRows__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
-// call: "obj->enlargeRows(x0_, x1_, x2_)"
-// params: [CInt,Ref (Const (StdVec CInt)),CBool]
-extern "C"
-void
-    casadi__Sparsity__enlargeRows__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2);
-void
-    casadi__Sparsity__enlargeRows__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        obj->enlargeRows(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::erase"
-// cWrapperName: "casadi__Sparsity__erase__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__erase__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// call: "obj->erase(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__erase__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
-std::vector< int >*
-    casadi__Sparsity__erase__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        std::vector< int > ret = obj->erase(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::erase"
-// cWrapperName: "casadi__Sparsity__erase__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__erase__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__erase__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
-std::vector< int >*
-    casadi__Sparsity__erase__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        std::vector< int > ret = obj->erase(x0_, x1_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::erase"
-// cWrapperName: "casadi__Sparsity__erase__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__erase__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->erase(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__erase__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
-std::vector< int >*
-    casadi__Sparsity__erase__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        std::vector< int > ret = obj->erase(x0_, x1_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "erase" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::erase"
-// cWrapperName: "casadi__Sparsity__erase__3"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__erase__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
-// call: "obj->erase(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CBool]
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__erase__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
-std::vector< int >*
-    casadi__Sparsity__erase__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        std::vector< int > ret = obj->erase(x0_, x1_, x2_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::find"
-// cWrapperName: "casadi__Sparsity__find__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__find__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->find()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__find__0(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__find__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->find();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "find" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::find"
-// cWrapperName: "casadi__Sparsity__find__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__find__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->find(x0_)"
-// params: [CBool]
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__find__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-std::vector< int >*
-    casadi__Sparsity__find__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        std::vector< int > ret = obj->find(x0_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getCCS" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getCCS"
-// cWrapperName: "casadi__Sparsity__getCCS"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__getCCS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->getCCS(x0_, x1_)"
-// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
-extern "C"
-void
-    casadi__Sparsity__getCCS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__Sparsity__getCCS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->getCCS(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getCRS" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getCRS"
-// cWrapperName: "casadi__Sparsity__getCRS"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__getCRS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->getCRS(x0_, x1_)"
-// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
-extern "C"
-void
-    casadi__Sparsity__getCRS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__Sparsity__getCRS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->getCRS(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getCol" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getCol"
-// cWrapperName: "casadi__Sparsity__getCol"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__getCol(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->getCol()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__getCol(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__getCol(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->getCol();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getColind" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getColind"
-// cWrapperName: "casadi__Sparsity__getColind"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__getColind(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->getColind()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__getColind(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__getColind(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->getColind();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDiag" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getDiag"
-// cWrapperName: "casadi__Sparsity__getDiag"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__getDiag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// call: "obj->getDiag(x0_)"
-// params: [Ref (StdVec CInt)]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__getDiag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__getDiag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->getDiag(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getLowerNZ" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getLowerNZ"
-// cWrapperName: "casadi__Sparsity__getLowerNZ"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__getLowerNZ(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->getLowerNZ()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__getLowerNZ(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__getLowerNZ(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->getLowerNZ();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getNZ"
-// cWrapperName: "casadi__Sparsity__getNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__getNZ__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// call: "obj->getNZ(x0_)"
-// params: [Ref (StdVec CInt)]
-extern "C"
-void
-    casadi__Sparsity__getNZ__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
-void
-    casadi__Sparsity__getNZ__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        obj->getNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getNZ"
-// cWrapperName: "casadi__Sparsity__getNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__getNZ__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->getNZ(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__getNZ__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
-std::vector< int >*
-    casadi__Sparsity__getNZ__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        std::vector< int > ret = obj->getNZ(x0_, x1_);
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getNZ" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getNZ"
-// cWrapperName: "casadi__Sparsity__getNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__getNZ__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// call: "obj->getNZ(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-int
-    casadi__Sparsity__getNZ__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
-int
-    casadi__Sparsity__getNZ__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        int ret = obj->getNZ(x0_, x1_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRow" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getRow"
-// cWrapperName: "casadi__Sparsity__getRow"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__getRow(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->getRow()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__getRow(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__getRow(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->getRow();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getTriplet" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getTriplet"
-// cWrapperName: "casadi__Sparsity__getTriplet"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__getTriplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->getTriplet(x0_, x1_)"
-// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
-extern "C"
-void
-    casadi__Sparsity__getTriplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
-void
-    casadi__Sparsity__getTriplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        obj->getTriplet(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "getUpperNZ" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::getUpperNZ"
-// cWrapperName: "casadi__Sparsity__getUpperNZ"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__getUpperNZ(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->getUpperNZ()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__getUpperNZ(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__getUpperNZ(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->getUpperNZ();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hasNZ" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::hasNZ"
-// cWrapperName: "casadi__Sparsity__hasNZ"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__hasNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// call: "obj->hasNZ(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-int
-    casadi__Sparsity__hasNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
-int
-    casadi__Sparsity__hasNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        bool ret = obj->hasNZ(x0_, x1_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "hash" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::hash"
-// cWrapperName: "casadi__Sparsity__hash"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CSize
-// cWrapperRetType: "size_t"
-// proto: "size_t\n    casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->hash()"
-// params: []
-extern "C"
-size_t
-    casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj);
-size_t
-    casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        size_t ret = obj->hash();
-        return WrapReturn< size_t, size_t >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isEqual" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isEqual"
-// cWrapperName: "casadi__Sparsity__isEqual__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isEqual__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "obj->isEqual(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-int
-    casadi__Sparsity__isEqual__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-int
-    casadi__Sparsity__isEqual__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        bool ret = obj->isEqual(x0_, x1_, x2_, x3_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isEqual" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isEqual"
-// cWrapperName: "casadi__Sparsity__isEqual__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isEqual__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->isEqual(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-int
-    casadi__Sparsity__isEqual__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-int
-    casadi__Sparsity__isEqual__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        bool ret = obj->isEqual(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isReshape" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isReshape"
-// cWrapperName: "casadi__Sparsity__isReshape"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->isReshape(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-int
-    casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-int
-    casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        bool ret = obj->isReshape(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isTranspose" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isTranspose"
-// cWrapperName: "casadi__Sparsity__isTranspose"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isTranspose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->isTranspose(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-int
-    casadi__Sparsity__isTranspose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-int
-    casadi__Sparsity__isTranspose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        bool ret = obj->isTranspose(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "iscolumn" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::iscolumn"
-// cWrapperName: "casadi__Sparsity__iscolumn"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__iscolumn(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->iscolumn()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__iscolumn(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__iscolumn(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->iscolumn();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isdense" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isdense"
-// cWrapperName: "casadi__Sparsity__isdense"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isdense(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->isdense()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__isdense(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__isdense(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->isdense();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isdiag" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isdiag"
-// cWrapperName: "casadi__Sparsity__isdiag"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isdiag(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->isdiag()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__isdiag(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__isdiag(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->isdiag();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isempty"
-// cWrapperName: "casadi__Sparsity__isempty__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isempty__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->isempty()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__isempty__0(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__isempty__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->isempty();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isempty" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isempty"
-// cWrapperName: "casadi__Sparsity__isempty__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isempty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->isempty(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__Sparsity__isempty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-int
-    casadi__Sparsity__isempty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isempty(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isrow" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isrow"
-// cWrapperName: "casadi__Sparsity__isrow"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isrow(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->isrow()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__isrow(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__isrow(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->isrow();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isscalar"
-// cWrapperName: "casadi__Sparsity__isscalar__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isscalar__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->isscalar()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__isscalar__0(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__isscalar__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->isscalar();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isscalar" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isscalar"
-// cWrapperName: "casadi__Sparsity__isscalar__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isscalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->isscalar(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__Sparsity__isscalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-int
-    casadi__Sparsity__isscalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->isscalar(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "issingular" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::issingular"
-// cWrapperName: "casadi__Sparsity__issingular"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__issingular(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->issingular()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__issingular(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__issingular(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->issingular();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "issquare" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::issquare"
-// cWrapperName: "casadi__Sparsity__issquare"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__issquare(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->issquare()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__issquare(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__issquare(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->issquare();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "issymmetric" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::issymmetric"
-// cWrapperName: "casadi__Sparsity__issymmetric"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__issymmetric(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->issymmetric()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__issymmetric(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__issymmetric(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->issymmetric();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istril" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::istril"
-// cWrapperName: "casadi__Sparsity__istril"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__istril(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->istril()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__istril(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__istril(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->istril();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "istriu" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::istriu"
-// cWrapperName: "casadi__Sparsity__istriu"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__istriu(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->istriu()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__istriu(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__istriu(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->istriu();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "isvector" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::isvector"
-// cWrapperName: "casadi__Sparsity__isvector"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__isvector(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->isvector()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__isvector(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__isvector(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->isvector();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "largestFirstOrdering" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::largestFirstOrdering"
-// cWrapperName: "casadi__Sparsity__largestFirstOrdering"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdVec CInt
-// cWrapperRetType: "std::vector< int >*"
-// proto: "std::vector< int >*\n    casadi__Sparsity__largestFirstOrdering(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->largestFirstOrdering()"
-// params: []
-extern "C"
-std::vector< int >*
-    casadi__Sparsity__largestFirstOrdering(std::string ** err_msg, casadi::Sparsity* obj);
-std::vector< int >*
-    casadi__Sparsity__largestFirstOrdering(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::vector< int > ret = obj->largestFirstOrdering();
-        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "lower" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::lower"
-// cWrapperName: "casadi__Sparsity__lower"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__lower(std::string ** err_msg, int x0)"
-// call: "casadi::Sparsity::lower(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__lower(std::string ** err_msg, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__lower(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::lower(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "makeDense" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::makeDense"
-// cWrapperName: "casadi__Sparsity__makeDense"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// call: "obj->makeDense(x0_)"
-// params: [Ref (StdVec CInt)]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->makeDense(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "nnz" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::nnz"
-// cWrapperName: "casadi__Sparsity__nnz"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__nnz(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->nnz()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__nnz(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__nnz(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->nnz();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "numel" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::numel"
-// cWrapperName: "casadi__Sparsity__numel"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->numel()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->numel();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator !=" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::operator !="
-// cWrapperName: "casadi__Sparsity__operator_nequals"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__operator_nequals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->operator !=(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-int
-    casadi__Sparsity__operator_nequals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-int
-    casadi__Sparsity__operator_nequals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        bool ret = obj->operator !=(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator *" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::operator *"
-// cWrapperName: "casadi__Sparsity__operator_mul"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__operator_mul(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->operator *(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__operator_mul(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-casadi::Sparsity*
-    casadi__Sparsity__operator_mul(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->operator *(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator +" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::operator +"
-// cWrapperName: "casadi__Sparsity__operator_plus"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__operator_plus(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->operator +(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__operator_plus(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-casadi::Sparsity*
-    casadi__Sparsity__operator_plus(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->operator +(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "operator ==" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::operator =="
-// cWrapperName: "casadi__Sparsity__operator_equals"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__operator_equals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->operator ==(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-int
-    casadi__Sparsity__operator_equals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-int
-    casadi__Sparsity__operator_equals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        bool ret = obj->operator ==(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "patternCombine" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::patternCombine"
-// cWrapperName: "casadi__Sparsity__patternCombine"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__patternCombine(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2)"
-// call: "obj->patternCombine(x0_, x1_, x2_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__patternCombine(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2);
-casadi::Sparsity*
-    casadi__Sparsity__patternCombine(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Sparsity ret = obj->patternCombine(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "patternIntersection" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::patternIntersection"
-// cWrapperName: "casadi__Sparsity__patternIntersection"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__patternIntersection(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->patternIntersection(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__patternIntersection(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-casadi::Sparsity*
-    casadi__Sparsity__patternIntersection(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->patternIntersection(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "patternInverse" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::patternInverse"
-// cWrapperName: "casadi__Sparsity__patternInverse"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__patternInverse(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->patternInverse()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__patternInverse(std::string ** err_msg, casadi::Sparsity* obj);
-casadi::Sparsity*
-    casadi__Sparsity__patternInverse(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        casadi::Sparsity ret = obj->patternInverse();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "patternProduct" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::patternProduct"
-// cWrapperName: "casadi__Sparsity__patternProduct"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__patternProduct(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->patternProduct(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__patternProduct(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-casadi::Sparsity*
-    casadi__Sparsity__patternProduct(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->patternProduct(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "patternUnion" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::patternUnion"
-// cWrapperName: "casadi__Sparsity__patternUnion"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__patternUnion(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->patternUnion(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__patternUnion(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-casadi::Sparsity*
-    casadi__Sparsity__patternUnion(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->patternUnion(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "pmult" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::pmult"
-// cWrapperName: "casadi__Sparsity__pmult__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// call: "obj->pmult(x0_)"
-// params: [Ref (Const (StdVec CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->pmult(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "pmult" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::pmult"
-// cWrapperName: "casadi__Sparsity__pmult__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
-// call: "obj->pmult(x0_, x1_)"
-// params: [Ref (Const (StdVec CInt)),CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        casadi::Sparsity ret = obj->pmult(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "pmult" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::pmult"
-// cWrapperName: "casadi__Sparsity__pmult__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
-// call: "obj->pmult(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),CBool,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2);
-casadi::Sparsity*
-    casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-
-        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "pmult" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::pmult"
-// cWrapperName: "casadi__Sparsity__pmult__3"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
-// call: "obj->pmult(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec CInt)),CBool,CBool,CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3);
-casadi::Sparsity*
-    casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-        bool x2_ = Marshaling<bool,int>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "printCompact" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::printCompact"
-// cWrapperName: "casadi__Sparsity__printCompact"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__printCompact(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->printCompact()"
-// params: []
-extern "C"
-void
-    casadi__Sparsity__printCompact(std::string ** err_msg, casadi::Sparsity* obj);
-void
-    casadi__Sparsity__printCompact(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        obj->printCompact();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reCache" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::reCache"
-// cWrapperName: "casadi__Sparsity__reCache"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__reCache(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->reCache()"
-// params: []
-extern "C"
-void
-    casadi__Sparsity__reCache(std::string ** err_msg, casadi::Sparsity* obj);
-void
-    casadi__Sparsity__reCache(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        obj->reCache();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "removeDuplicates" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::removeDuplicates"
-// cWrapperName: "casadi__Sparsity__removeDuplicates"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// call: "obj->removeDuplicates(x0_)"
-// params: [Ref (StdVec CInt)]
-extern "C"
-void
-    casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
-void
-    casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        obj->removeDuplicates(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "reserve" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::reserve"
-// cWrapperName: "casadi__Sparsity__reserve"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__reserve(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// call: "obj->reserve(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__Sparsity__reserve(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
-void
-    casadi__Sparsity__reserve(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->reserve(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "resize" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::resize"
-// cWrapperName: "casadi__Sparsity__resize"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// call: "obj->resize(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-void
-    casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
-void
-    casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->resize(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "row" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::row"
-// cWrapperName: "casadi__Sparsity__row"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__row(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->row(x0_)"
-// params: [CInt]
-extern "C"
-int
-    casadi__Sparsity__row(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-int
-    casadi__Sparsity__row(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        int ret = obj->row(x0_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "rowcol" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::rowcol"
-// cWrapperName: "casadi__Sparsity__rowcol"
-// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
-// call: "casadi::Sparsity::rowcol(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3);
-casadi::Sparsity*
-    casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        int x2_ = Marshaling<int,int>::marshal(x2);
-        int x3_ = Marshaling<int,int>::marshal(x3);
-
-        casadi::Sparsity ret = casadi::Sparsity::rowcol(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "rowsSequential" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::rowsSequential"
-// cWrapperName: "casadi__Sparsity__rowsSequential__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->rowsSequential()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        bool ret = obj->rowsSequential();
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "rowsSequential" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::rowsSequential"
-// cWrapperName: "casadi__Sparsity__rowsSequential__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->rowsSequential(x0_)"
-// params: [CBool]
-extern "C"
-int
-    casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-int
-    casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        bool ret = obj->rowsSequential(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sanityCheck"
-// cWrapperName: "casadi__Sparsity__sanityCheck__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__sanityCheck__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->sanityCheck()"
-// params: []
-extern "C"
-void
-    casadi__Sparsity__sanityCheck__0(std::string ** err_msg, casadi::Sparsity* obj);
-void
-    casadi__Sparsity__sanityCheck__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        obj->sanityCheck();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "sanityCheck" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sanityCheck"
-// cWrapperName: "casadi__Sparsity__sanityCheck__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__sanityCheck__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->sanityCheck(x0_)"
-// params: [CBool]
-extern "C"
-void
-    casadi__Sparsity__sanityCheck__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-void
-    casadi__Sparsity__sanityCheck__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        obj->sanityCheck(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "scalar" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::scalar"
-// cWrapperName: "casadi__Sparsity__scalar__0"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__scalar__0(std::string ** err_msg)"
-// call: "casadi::Sparsity::scalar()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__scalar__0(std::string ** err_msg);
-casadi::Sparsity*
-    casadi__Sparsity__scalar__0(std::string ** err_msg){
-    try {
-
-        casadi::Sparsity ret = casadi::Sparsity::scalar();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "scalar" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::scalar"
-// cWrapperName: "casadi__Sparsity__scalar__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__scalar__1(std::string ** err_msg, int x0)"
-// call: "casadi::Sparsity::scalar(x0_)"
-// params: [CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__scalar__1(std::string ** err_msg, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__scalar__1(std::string ** err_msg, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::scalar(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "shape" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::shape"
-// cWrapperName: "casadi__Sparsity__shape"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: StdPair CInt CInt
-// cWrapperRetType: "std::pair< int, int >*"
-// proto: "std::pair< int, int >*\n    casadi__Sparsity__shape(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->shape()"
-// params: []
-extern "C"
-std::pair< int, int >*
-    casadi__Sparsity__shape(std::string ** err_msg, casadi::Sparsity* obj);
-std::pair< int, int >*
-    casadi__Sparsity__shape(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        std::pair< int, int > ret = obj->shape();
-        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size1" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::size1"
-// cWrapperName: "casadi__Sparsity__size1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->size1()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->size1();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "size2" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::size2"
-// cWrapperName: "casadi__Sparsity__size2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->size2()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->size2();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeD" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sizeD"
-// cWrapperName: "casadi__Sparsity__sizeD"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__sizeD(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->sizeD()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__sizeD(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__sizeD(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->sizeD();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeL" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sizeL"
-// cWrapperName: "casadi__Sparsity__sizeL"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__sizeL(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->sizeL()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__sizeL(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__sizeL(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->sizeL();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sizeU" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sizeU"
-// cWrapperName: "casadi__Sparsity__sizeU"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__sizeU(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->sizeU()"
-// params: []
-extern "C"
-int
-    casadi__Sparsity__sizeU(std::string ** err_msg, casadi::Sparsity* obj);
-int
-    casadi__Sparsity__sizeU(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        int ret = obj->sizeU();
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sparse"
-// cWrapperName: "casadi__Sparsity__sparse__0"
-// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__sparse__0(std::string ** err_msg, std::pair< int, int >* x0)"
-// call: "casadi::Sparsity::sparse(x0_)"
-// params: [Ref (Const (StdPair CInt CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__sparse__0(std::string ** err_msg, std::pair< int, int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__sparse__0(std::string ** err_msg, std::pair< int, int >* x0){
-    try {
-        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::sparse(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sparse"
-// cWrapperName: "casadi__Sparsity__sparse__1"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__sparse__1(std::string ** err_msg, int x0)"
-// call: "casadi::Sparsity::sparse(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__sparse__1(std::string ** err_msg, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__sparse__1(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::sparse(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "sparse" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sparse"
-// cWrapperName: "casadi__Sparsity__sparse__2"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__sparse__2(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Sparsity::sparse(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__sparse__2(std::string ** err_msg, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__sparse__2(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = casadi::Sparsity::sparse(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "spy" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::spy"
-// cWrapperName: "casadi__Sparsity__spy"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->spy()"
-// params: []
-extern "C"
-void
-    casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj);
-void
-    casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        obj->spy();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "spyMatlab" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::spyMatlab"
-// cWrapperName: "casadi__Sparsity__spyMatlab"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__Sparsity__spyMatlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0)"
-// call: "obj->spyMatlab(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__Sparsity__spyMatlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0);
-void
-    casadi__Sparsity__spyMatlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->spyMatlab(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "starColoring" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::starColoring"
-// cWrapperName: "casadi__Sparsity__starColoring__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__starColoring__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->starColoring()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__starColoring__0(std::string ** err_msg, casadi::Sparsity* obj);
-casadi::Sparsity*
-    casadi__Sparsity__starColoring__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        casadi::Sparsity ret = obj->starColoring();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "starColoring" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::starColoring"
-// cWrapperName: "casadi__Sparsity__starColoring__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__starColoring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->starColoring(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__starColoring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__starColoring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->starColoring(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "starColoring" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::starColoring"
-// cWrapperName: "casadi__Sparsity__starColoring__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__starColoring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// call: "obj->starColoring(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__starColoring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__starColoring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = obj->starColoring(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "starColoring2" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::starColoring2"
-// cWrapperName: "casadi__Sparsity__starColoring2__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__starColoring2__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->starColoring2()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__starColoring2__0(std::string ** err_msg, casadi::Sparsity* obj);
-casadi::Sparsity*
-    casadi__Sparsity__starColoring2__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        casadi::Sparsity ret = obj->starColoring2();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "starColoring2" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::starColoring2"
-// cWrapperName: "casadi__Sparsity__starColoring2__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__starColoring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->starColoring2(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__starColoring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__starColoring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->starColoring2(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "starColoring2" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::starColoring2"
-// cWrapperName: "casadi__Sparsity__starColoring2__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__starColoring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
-// call: "obj->starColoring2(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__starColoring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__starColoring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = obj->starColoring2(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "stronglyConnectedComponents" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::stronglyConnectedComponents"
-// cWrapperName: "casadi__Sparsity__stronglyConnectedComponents"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// args: "(x0_, x1_)"
-// rettype: CInt
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__Sparsity__stronglyConnectedComponents(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
-// call: "obj->stronglyConnectedComponents(x0_, x1_)"
-// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
-extern "C"
-int
-    casadi__Sparsity__stronglyConnectedComponents(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
-int
-    casadi__Sparsity__stronglyConnectedComponents(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-
-        int ret = obj->stronglyConnectedComponents(x0_, x1_);
-        return WrapReturn< int, int >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sub" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sub"
-// cWrapperName: "casadi__Sparsity__sub__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2)"
-// call: "obj->sub(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (StdVec CInt)]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__sub__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2);
-casadi::Sparsity*
-    casadi__Sparsity__sub__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-
-        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sub" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sub"
-// cWrapperName: "casadi__Sparsity__sub__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2, int x3)"
-// call: "obj->sub(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (StdVec CInt),CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__sub__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2, int x3);
-casadi::Sparsity*
-    casadi__Sparsity__sub__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >* x2, int x3){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sub" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sub"
-// cWrapperName: "casadi__Sparsity__sub__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
-// call: "obj->sub(x0_, x1_, x2_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (StdVec CInt)]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__sub__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
-casadi::Sparsity*
-    casadi__Sparsity__sub__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-
-        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "sub" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::sub"
-// cWrapperName: "casadi__Sparsity__sub__3"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3)"
-// call: "obj->sub(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (StdVec CInt),CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__sub__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3);
-casadi::Sparsity*
-    casadi__Sparsity__sub__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        bool x3_ = Marshaling<bool,int>::marshal(x3);
-
-        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "transpose" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::transpose"
-// cWrapperName: "casadi__Sparsity__transpose__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
-// call: "obj->transpose(x0_)"
-// params: [Ref (StdVec CInt)]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
-casadi::Sparsity*
-    casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->transpose(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "transpose" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::transpose"
-// cWrapperName: "casadi__Sparsity__transpose__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
-// call: "obj->transpose(x0_, x1_)"
-// params: [Ref (StdVec CInt),CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
-    try {
-        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
-        bool x1_ = Marshaling<bool,int>::marshal(x1);
-
-        casadi::Sparsity ret = obj->transpose(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::triplet"
-// cWrapperName: "casadi__Sparsity__triplet__0"
-// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
-// call: "casadi::Sparsity::triplet(x0_, x1_, x2_, x3_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
-casadi::Sparsity*
-    casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-
-        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::triplet"
-// cWrapperName: "casadi__Sparsity__triplet__1"
-// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4)"
-// args: "(x0_, x1_, x2_, x3_, x4_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4)"
-// call: "casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (StdVec CInt)]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4);
-casadi::Sparsity*
-    casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-
-        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "triplet" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::triplet"
-// cWrapperName: "casadi__Sparsity__triplet__2"
-// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
-// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
-// call: "casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_, x5_)"
-// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (StdVec CInt),CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5);
-casadi::Sparsity*
-    casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
-        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
-        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
-        bool x5_ = Marshaling<bool,int>::marshal(x5);
-
-        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_, x5_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "unidirectionalColoring" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::unidirectionalColoring"
-// cWrapperName: "casadi__Sparsity__unidirectionalColoring__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__unidirectionalColoring__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->unidirectionalColoring()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__unidirectionalColoring__0(std::string ** err_msg, casadi::Sparsity* obj);
-casadi::Sparsity*
-    casadi__Sparsity__unidirectionalColoring__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        casadi::Sparsity ret = obj->unidirectionalColoring();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "unidirectionalColoring" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::unidirectionalColoring"
-// cWrapperName: "casadi__Sparsity__unidirectionalColoring__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__unidirectionalColoring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
-// call: "obj->unidirectionalColoring(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__unidirectionalColoring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
-casadi::Sparsity*
-    casadi__Sparsity__unidirectionalColoring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-
-        casadi::Sparsity ret = obj->unidirectionalColoring(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "unidirectionalColoring" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::unidirectionalColoring"
-// cWrapperName: "casadi__Sparsity__unidirectionalColoring__2"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__unidirectionalColoring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1)"
-// call: "obj->unidirectionalColoring(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__unidirectionalColoring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__unidirectionalColoring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1){
-    try {
-        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = obj->unidirectionalColoring(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "unit" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::unit"
-// cWrapperName: "casadi__Sparsity__unit"
-// protoArgs: "(std::string ** err_msg, int x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1)"
-// call: "casadi::Sparsity::unit(x0_, x1_)"
-// params: [CInt,CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1);
-casadi::Sparsity*
-    casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        casadi::Sparsity ret = casadi::Sparsity::unit(x0_, x1_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "upper" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::upper"
-// cWrapperName: "casadi__Sparsity__upper"
-// protoArgs: "(std::string ** err_msg, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__upper(std::string ** err_msg, int x0)"
-// call: "casadi::Sparsity::upper(x0_)"
-// params: [CInt]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__upper(std::string ** err_msg, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__upper(std::string ** err_msg, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::Sparsity ret = casadi::Sparsity::upper(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "zz_tril" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::zz_tril"
-// cWrapperName: "casadi__Sparsity__zz_tril__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__zz_tril__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->zz_tril()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__zz_tril__0(std::string ** err_msg, casadi::Sparsity* obj);
-casadi::Sparsity*
-    casadi__Sparsity__zz_tril__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        casadi::Sparsity ret = obj->zz_tril();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "zz_tril" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::zz_tril"
-// cWrapperName: "casadi__Sparsity__zz_tril__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__zz_tril__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->zz_tril(x0_)"
-// params: [CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__zz_tril__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__zz_tril__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->zz_tril(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "zz_triu" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::zz_triu"
-// cWrapperName: "casadi__Sparsity__zz_triu__0"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__zz_triu__0(std::string ** err_msg, casadi::Sparsity* obj)"
-// call: "obj->zz_triu()"
-// params: []
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__zz_triu__0(std::string ** err_msg, casadi::Sparsity* obj);
-casadi::Sparsity*
-    casadi__Sparsity__zz_triu__0(std::string ** err_msg, casadi::Sparsity* obj){
-    try {
-
-        casadi::Sparsity ret = obj->zz_triu();
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "zz_triu" ===============
-// class: "casadi::Sparsity"
-// cppName: "casadi::Sparsity::zz_triu"
-// cWrapperName: "casadi__Sparsity__zz_triu__1"
-// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
-// cWrapperRetType: "casadi::Sparsity*"
-// proto: "casadi::Sparsity*\n    casadi__Sparsity__zz_triu__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
-// call: "obj->zz_triu(x0_)"
-// params: [CBool]
-extern "C"
-casadi::Sparsity*
-    casadi__Sparsity__zz_triu__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
-casadi::Sparsity*
-    casadi__Sparsity__zz_triu__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
-    try {
-        bool x0_ = Marshaling<bool,int>::marshal(x0);
-
-        casadi::Sparsity ret = obj->zz_triu(x0_);
-        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "SparsityInterfaceCommon")===============
-// classType: UserType (Namespace ["casadi"]) (Name "SparsityInterfaceCommon")
-extern "C"
-void delete_casadi__SparsityInterfaceCommon(casadi::SparsityInterfaceCommon* obj);
-void delete_casadi__SparsityInterfaceCommon(casadi::SparsityInterfaceCommon* obj){
-    delete obj;
-}
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "StabilizedQpSolver")===============
-// classType: UserType (Namespace ["casadi"]) (Name "StabilizedQpSolver")
-extern "C"
-void delete_casadi__StabilizedQpSolver(casadi::StabilizedQpSolver* obj);
-void delete_casadi__StabilizedQpSolver(casadi::StabilizedQpSolver* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::StabilizedQpSolver"
-// cppName: "casadi::StabilizedQpSolver"
-// cWrapperName: "casadi__StabilizedQpSolver__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "StabilizedQpSolver")
-// cWrapperRetType: "casadi::StabilizedQpSolver*"
-// proto: "casadi::StabilizedQpSolver*\n    casadi__StabilizedQpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2)"
-// call: "casadi::StabilizedQpSolver(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
-extern "C"
-casadi::StabilizedQpSolver*
-    casadi__StabilizedQpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2);
-casadi::StabilizedQpSolver*
-    casadi__StabilizedQpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-
-        return new casadi::StabilizedQpSolver(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::StabilizedQpSolver"
-// cppName: "casadi::StabilizedQpSolver"
-// cWrapperName: "casadi__StabilizedQpSolver__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "StabilizedQpSolver")
-// cWrapperRetType: "casadi::StabilizedQpSolver*"
-// proto: "casadi::StabilizedQpSolver*\n    casadi__StabilizedQpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::StabilizedQpSolver(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::StabilizedQpSolver*
-    casadi__StabilizedQpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::StabilizedQpSolver*
-    casadi__StabilizedQpSolver__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::Sparsity* >* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-        std::map< std::string, casadi::Sparsity > x2_ = Marshaling<std::map< std::string, casadi::Sparsity >,std::map< std::string, casadi::Sparsity* >*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::StabilizedQpSolver(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::StabilizedQpSolver"
-// cppName: "casadi::StabilizedQpSolver"
-// cWrapperName: "casadi__StabilizedQpSolver__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "StabilizedQpSolver")
-// cWrapperRetType: "casadi::StabilizedQpSolver*"
-// proto: "casadi::StabilizedQpSolver*\n    casadi__StabilizedQpSolver__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::StabilizedQpSolver()"
-// params: []
-extern "C"
-casadi::StabilizedQpSolver*
-    casadi__StabilizedQpSolver__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::StabilizedQpSolver*
-    casadi__StabilizedQpSolver__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::StabilizedQpSolver();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::StabilizedQpSolver"
-// cppName: "casadi::StabilizedQpSolver::doc"
-// cWrapperName: "casadi__StabilizedQpSolver__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__StabilizedQpSolver__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::StabilizedQpSolver::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__StabilizedQpSolver__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__StabilizedQpSolver__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::StabilizedQpSolver::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "generateNativeCode" ===============
-// class: "casadi::StabilizedQpSolver"
-// cppName: "casadi::StabilizedQpSolver::generateNativeCode"
-// cWrapperName: "casadi__StabilizedQpSolver__generateNativeCode"
-// protoArgs: "(std::string ** err_msg, casadi::StabilizedQpSolver* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__StabilizedQpSolver__generateNativeCode(std::string ** err_msg, casadi::StabilizedQpSolver* obj, std::string* x0)"
-// call: "obj->generateNativeCode(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__StabilizedQpSolver__generateNativeCode(std::string ** err_msg, casadi::StabilizedQpSolver* obj, std::string* x0);
-void
-    casadi__StabilizedQpSolver__generateNativeCode(std::string ** err_msg, casadi::StabilizedQpSolver* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        obj->generateNativeCode(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Static method: "hasPlugin" ===============
-// class: "casadi::StabilizedQpSolver"
-// cppName: "casadi::StabilizedQpSolver::hasPlugin"
-// cWrapperName: "casadi__StabilizedQpSolver__hasPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CBool
-// cWrapperRetType: "int"
-// proto: "int\n    casadi__StabilizedQpSolver__hasPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::StabilizedQpSolver::hasPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-int
-    casadi__StabilizedQpSolver__hasPlugin(std::string ** err_msg, std::string* x0);
-int
-    casadi__StabilizedQpSolver__hasPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        bool ret = casadi::StabilizedQpSolver::hasPlugin(x0_);
-        return WrapReturn< int, bool >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::StabilizedQpSolver"
-// cppName: "casadi::StabilizedQpSolver::loadPlugin"
-// cWrapperName: "casadi__StabilizedQpSolver__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__StabilizedQpSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::StabilizedQpSolver::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__StabilizedQpSolver__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__StabilizedQpSolver__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::StabilizedQpSolver::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Switch")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Switch")
-extern "C"
-void delete_casadi__Switch(casadi::Switch* obj);
-void delete_casadi__Switch(casadi::Switch* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Switch"
-// cppName: "casadi::Switch"
-// cWrapperName: "casadi__Switch__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Switch")
-// cWrapperRetType: "casadi::Switch*"
-// proto: "casadi::Switch*\n    casadi__Switch__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2)"
-// call: "casadi::Switch(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2);
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-
-        return new casadi::Switch(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Switch"
-// cppName: "casadi::Switch"
-// cWrapperName: "casadi__Switch__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Switch")
-// cWrapperRetType: "casadi::Switch*"
-// proto: "casadi::Switch*\n    casadi__Switch__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::Switch(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::Switch(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Switch"
-// cppName: "casadi::Switch"
-// cWrapperName: "casadi__Switch__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2)"
-// args: "(x0_, x1_, x2_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Switch")
-// cWrapperRetType: "casadi::Switch*"
-// proto: "casadi::Switch*\n    casadi__Switch__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2)"
-// call: "casadi::Switch(x0_, x1_, x2_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Function")))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
-extern "C"
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2);
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::Function > x1_ = Marshaling<std::vector< casadi::Function >,std::vector< casadi::Function* >*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-
-        return new casadi::Switch(x0_, x1_, x2_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Switch"
-// cppName: "casadi::Switch"
-// cWrapperName: "casadi__Switch__CONSTRUCTOR__3"
-// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// args: "(x0_, x1_, x2_, x3_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Switch")
-// cWrapperRetType: "casadi::Switch*"
-// proto: "casadi::Switch*\n    casadi__Switch__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
-// call: "casadi::Switch(x0_, x1_, x2_, x3_)"
-// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Function")))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))))]
-extern "C"
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3);
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        std::vector< casadi::Function > x1_ = Marshaling<std::vector< casadi::Function >,std::vector< casadi::Function* >*>::marshal(x1);
-        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
-        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
-
-        return new casadi::Switch(x0_, x1_, x2_, x3_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Switch"
-// cppName: "casadi::Switch"
-// cWrapperName: "casadi__Switch__CONSTRUCTOR__4"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Switch")
-// cWrapperRetType: "casadi::Switch*"
-// proto: "casadi::Switch*\n    casadi__Switch__CONSTRUCTOR__4(std::string ** err_msg)"
-// call: "casadi::Switch()"
-// params: []
-extern "C"
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__4(std::string ** err_msg);
-casadi::Switch*
-    casadi__Switch__CONSTRUCTOR__4(std::string ** err_msg){
-    try {
-
-        return new casadi::Switch();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "Variable")===============
-// classType: UserType (Namespace ["casadi"]) (Name "Variable")
-extern "C"
-void delete_casadi__Variable(casadi::Variable* obj);
-void delete_casadi__Variable(casadi::Variable* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Variable"
-// cppName: "casadi::Variable"
-// cWrapperName: "casadi__Variable__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
-// cWrapperRetType: "casadi::Variable*"
-// proto: "casadi::Variable*\n    casadi__Variable__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0)"
-// call: "casadi::Variable(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::Variable*
-    casadi__Variable__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0);
-casadi::Variable*
-    casadi__Variable__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        return new casadi::Variable(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Variable"
-// cppName: "casadi::Variable"
-// cWrapperName: "casadi__Variable__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// args: "(x0_, x1_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
-// cWrapperRetType: "casadi::Variable*"
-// proto: "casadi::Variable*\n    casadi__Variable__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
-// call: "casadi::Variable(x0_, x1_)"
-// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
-extern "C"
-casadi::Variable*
-    casadi__Variable__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
-casadi::Variable*
-    casadi__Variable__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
-
-        return new casadi::Variable(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::Variable"
-// cppName: "casadi::Variable"
-// cWrapperName: "casadi__Variable__CONSTRUCTOR__2"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
-// cWrapperRetType: "casadi::Variable*"
-// proto: "casadi::Variable*\n    casadi__Variable__CONSTRUCTOR__2(std::string ** err_msg)"
-// call: "casadi::Variable()"
-// params: []
-extern "C"
-casadi::Variable*
-    casadi__Variable__CONSTRUCTOR__2(std::string ** err_msg);
-casadi::Variable*
-    casadi__Variable__CONSTRUCTOR__2(std::string ** err_msg){
-    try {
-
-        return new casadi::Variable();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "name" ===============
-// class: "casadi::Variable"
-// cppName: "casadi::Variable::name"
-// cWrapperName: "casadi__Variable__name"
-// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj)"
-// call: "obj->name()"
-// params: []
-extern "C"
-std::string*
-    casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj);
-std::string*
-    casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj){
-    try {
-
-        std::string ret = obj->name();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getRepresentation" ===============
-// class: "casadi::Variable"
-// cppName: "casadi::Variable::getRepresentation"
-// cWrapperName: "casadi__Variable__getRepresentation"
-// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj)"
-// call: "obj->getRepresentation()"
-// params: []
-extern "C"
-std::string*
-    casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj);
-std::string*
-    casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj){
-    try {
-
-        std::string ret = obj->getRepresentation();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getDescription" ===============
-// class: "casadi::Variable"
-// cppName: "casadi::Variable::getDescription"
-// cWrapperName: "casadi__Variable__getDescription"
-// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
-// args: "()"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj)"
-// call: "obj->getDescription()"
-// params: []
-extern "C"
-std::string*
-    casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj);
-std::string*
-    casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj){
-    try {
-
-        std::string ret = obj->getDescription();
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-
-// ================== delete UserType (Namespace ["casadi"]) (Name "XmlFile")===============
-// classType: UserType (Namespace ["casadi"]) (Name "XmlFile")
-extern "C"
-void delete_casadi__XmlFile(casadi::XmlFile* obj);
-void delete_casadi__XmlFile(casadi::XmlFile* obj){
-    delete obj;
-}
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::XmlFile"
-// cppName: "casadi::XmlFile"
-// cWrapperName: "casadi__XmlFile__CONSTRUCTOR__0"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "XmlFile")
-// cWrapperRetType: "casadi::XmlFile*"
-// proto: "casadi::XmlFile*\n    casadi__XmlFile__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0)"
-// call: "casadi::XmlFile(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::XmlFile*
-    casadi__XmlFile__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0);
-casadi::XmlFile*
-    casadi__XmlFile__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        return new casadi::XmlFile(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Constructor method: "CONSTRUCTOR" ===============
-// class: "casadi::XmlFile"
-// cppName: "casadi::XmlFile"
-// cWrapperName: "casadi__XmlFile__CONSTRUCTOR__1"
-// protoArgs: "(std::string ** err_msg)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "XmlFile")
-// cWrapperRetType: "casadi::XmlFile*"
-// proto: "casadi::XmlFile*\n    casadi__XmlFile__CONSTRUCTOR__1(std::string ** err_msg)"
-// call: "casadi::XmlFile()"
-// params: []
-extern "C"
-casadi::XmlFile*
-    casadi__XmlFile__CONSTRUCTOR__1(std::string ** err_msg);
-casadi::XmlFile*
-    casadi__XmlFile__CONSTRUCTOR__1(std::string ** err_msg){
-    try {
-
-        return new casadi::XmlFile();
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "doc" ===============
-// class: "casadi::XmlFile"
-// cppName: "casadi::XmlFile::doc"
-// cWrapperName: "casadi__XmlFile__doc"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: StdString
-// cWrapperRetType: "std::string*"
-// proto: "std::string*\n    casadi__XmlFile__doc(std::string ** err_msg, std::string* x0)"
-// call: "casadi::XmlFile::doc(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-std::string*
-    casadi__XmlFile__doc(std::string ** err_msg, std::string* x0);
-std::string*
-    casadi__XmlFile__doc(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        std::string ret = casadi::XmlFile::doc(x0_);
-        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Static method: "loadPlugin" ===============
-// class: "casadi::XmlFile"
-// cppName: "casadi::XmlFile::loadPlugin"
-// cWrapperName: "casadi__XmlFile__loadPlugin"
-// protoArgs: "(std::string ** err_msg, std::string* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__XmlFile__loadPlugin(std::string ** err_msg, std::string* x0)"
-// call: "casadi::XmlFile::loadPlugin(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-void
-    casadi__XmlFile__loadPlugin(std::string ** err_msg, std::string* x0);
-void
-    casadi__XmlFile__loadPlugin(std::string ** err_msg, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::XmlFile::loadPlugin(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-
-// ================== delete IOInterface (UserType (Namespace ["casadi"]) (Name "Function"))===============
-// classType: IOInterface (UserType (Namespace ["casadi"]) (Name "Function"))
-extern "C"
-void delete_casadi__IOInterface_casadi__Function_(casadi::IOInterface< casadi::Function* >* obj);
-void delete_casadi__IOInterface_casadi__Function_(casadi::IOInterface< casadi::Function* >* obj){
-    delete obj;
-}
-
-// ================== Normal method: "getInput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::getInput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___getInput__0"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__IOInterface_casadi__Function___getInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
-// call: "obj->getInput(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::DMatrix ret = obj->getInput(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getInput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::getInput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___getInput__1"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__IOInterface_casadi__Function___getInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
-// call: "obj->getInput()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
-    try {
-
-        casadi::DMatrix ret = obj->getInput();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getInput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::getInput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___getInput__2"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__IOInterface_casadi__Function___getInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
-// call: "obj->getInput(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = obj->getInput(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOutput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::getOutput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___getOutput__0"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__IOInterface_casadi__Function___getOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
-// call: "obj->getOutput(x0_)"
-// params: [Ref (Const StdString)]
-extern "C"
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
-    try {
-        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
-
-        casadi::DMatrix ret = obj->getOutput(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOutput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::getOutput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___getOutput__1"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
-// args: "()"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__IOInterface_casadi__Function___getOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
-// call: "obj->getOutput()"
-// params: []
-extern "C"
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
-    try {
-
-        casadi::DMatrix ret = obj->getOutput();
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "getOutput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::getOutput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___getOutput__2"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
-// args: "(x0_)"
-// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
-// cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix*\n    casadi__IOInterface_casadi__Function___getOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
-// call: "obj->getOutput(x0_)"
-// params: [CInt]
-extern "C"
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
-casadi::DMatrix*
-    casadi__IOInterface_casadi__Function___getOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
-    try {
-        int x0_ = Marshaling<int,int>::marshal(x0);
-
-        casadi::DMatrix ret = obj->getOutput(x0_);
-        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return 0;
-    }
-}
-
-
-// ================== Normal method: "setInput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setInput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__0"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// call: "obj->setInput(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1);
-void
-    casadi__IOInterface_casadi__Function___setInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->setInput(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setInput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__1"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// call: "obj->setInput(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0);
-void
-    casadi__IOInterface_casadi__Function___setInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        obj->setInput(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setInput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__2"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// call: "obj->setInput(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1);
-void
-    casadi__IOInterface_casadi__Function___setInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setInput(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInputNZ" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setInputNZ"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setInputNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setInputNZ__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// call: "obj->setInputNZ(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setInputNZ__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1);
-void
-    casadi__IOInterface_casadi__Function___setInputNZ__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->setInputNZ(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInputNZ" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setInputNZ"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setInputNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setInputNZ__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// call: "obj->setInputNZ(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setInputNZ__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0);
-void
-    casadi__IOInterface_casadi__Function___setInputNZ__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        obj->setInputNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setInputNZ" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setInputNZ"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setInputNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setInputNZ__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// call: "obj->setInputNZ(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setInputNZ__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1);
-void
-    casadi__IOInterface_casadi__Function___setInputNZ__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setInputNZ(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOutput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__0"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// call: "obj->setOutput(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1);
-void
-    casadi__IOInterface_casadi__Function___setOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->setOutput(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOutput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__1"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// call: "obj->setOutput(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0);
-void
-    casadi__IOInterface_casadi__Function___setOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        obj->setOutput(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOutput" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__2"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// call: "obj->setOutput(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1);
-void
-    casadi__IOInterface_casadi__Function___setOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setOutput(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOutputNZ" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setOutputNZ"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setOutputNZ__0"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setOutputNZ__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
-// call: "obj->setOutputNZ(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setOutputNZ__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1);
-void
-    casadi__IOInterface_casadi__Function___setOutputNZ__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
-
-        obj->setOutputNZ(x0_, x1_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOutputNZ" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setOutputNZ"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setOutputNZ__1"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// args: "(x0_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setOutputNZ__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
-// call: "obj->setOutputNZ(x0_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setOutputNZ__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0);
-void
-    casadi__IOInterface_casadi__Function___setOutputNZ__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-
-        obj->setOutputNZ(x0_);
-    } catch (std::exception& ex) {
-         *err_msg = new std::string(ex.what());
-         return;
-    }
-}
-
-
-// ================== Normal method: "setOutputNZ" ===============
-// class: "casadi::IOInterface< casadi::Function >"
-// cppName: "casadi::IOInterface< casadi::Function >::setOutputNZ"
-// cWrapperName: "casadi__IOInterface_casadi__Function___setOutputNZ__2"
-// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// args: "(x0_, x1_)"
-// rettype: CVoid
-// cWrapperRetType: "void"
-// proto: "void\n    casadi__IOInterface_casadi__Function___setOutputNZ__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
-// call: "obj->setOutputNZ(x0_, x1_)"
-// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
-extern "C"
-void
-    casadi__IOInterface_casadi__Function___setOutputNZ__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1);
-void
-    casadi__IOInterface_casadi__Function___setOutputNZ__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1){
-    try {
-        casadi::DMatrix& x0_ = Marshaling<casadi::DMatrix&,casadi::DMatrix*>::marshal(x0);
-        int x1_ = Marshaling<int,int>::marshal(x1);
-
-        obj->setOutputNZ(x0_, x1_);
+// protoArgs: "(std::string ** err_msg, casadi::Callback* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Callback")
+// cWrapperRetType: "casadi::Callback*"
+// proto: "casadi::Callback*\n    casadi__Callback__CONSTRUCTOR__0(std::string ** err_msg, casadi::Callback* x0)"
+// call: "        casadi::Callback* ret = (casadi::Callback*)new casadi::Callback(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Callback"))),SwigOutput False)]
+extern "C"
+casadi::Callback*
+    casadi__Callback__CONSTRUCTOR__0(std::string ** err_msg, casadi::Callback* x0);
+casadi::Callback*
+    casadi__Callback__CONSTRUCTOR__0(std::string ** err_msg, casadi::Callback* x0){
+    try {
+        casadi::Callback& x0_ = Marshaling<casadi::Callback&,casadi::Callback*>::marshal(x0);
+
+        casadi::Callback* ret = (casadi::Callback*)new casadi::Callback(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback"
+// cWrapperName: "casadi__Callback__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Callback")
+// cWrapperRetType: "casadi::Callback*"
+// proto: "casadi::Callback*\n    casadi__Callback__CONSTRUCTOR__1(std::string ** err_msg)"
+// call: "        casadi::Callback* ret = (casadi::Callback*)new casadi::Callback();"
+// params: []
+extern "C"
+casadi::Callback*
+    casadi__Callback__CONSTRUCTOR__1(std::string ** err_msg);
+casadi::Callback*
+    casadi__Callback__CONSTRUCTOR__1(std::string ** err_msg){
+    try {
+
+        casadi::Callback* ret = (casadi::Callback*)new casadi::Callback();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "construct" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::construct"
+// cWrapperName: "casadi__Callback__construct__0"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Callback__construct__0(std::string ** err_msg, casadi::Callback* obj, std::string* x0)"
+// call: "        obj->construct(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Callback__construct__0(std::string ** err_msg, casadi::Callback* obj, std::string* x0);
+void
+    casadi__Callback__construct__0(std::string ** err_msg, casadi::Callback* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->construct(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "construct" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::construct"
+// cWrapperName: "casadi__Callback__construct__1"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Callback__construct__1(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// call: "        obj->construct(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+void
+    casadi__Callback__construct__1(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
+void
+    casadi__Callback__construct__1(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
+
+        obj->construct(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "eval" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::eval"
+// cWrapperName: "casadi__Callback__eval"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, std::vector< casadi::DM* >* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DM"))
+// cWrapperRetType: "std::vector< casadi::DM* >*"
+// proto: "std::vector< casadi::DM* >*\n    casadi__Callback__eval(std::string ** err_msg, casadi::Callback* obj, std::vector< casadi::DM* >* x0)"
+// call: "        std::vector< casadi::DM > ret = obj->eval(x0_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False)]
+extern "C"
+std::vector< casadi::DM* >*
+    casadi__Callback__eval(std::string ** err_msg, casadi::Callback* obj, std::vector< casadi::DM* >* x0);
+std::vector< casadi::DM* >*
+    casadi__Callback__eval(std::string ** err_msg, casadi::Callback* obj, std::vector< casadi::DM* >* x0){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+
+        std::vector< casadi::DM > ret = obj->eval(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "finalize" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::finalize"
+// cWrapperName: "casadi__Callback__finalize"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Callback__finalize(std::string ** err_msg, casadi::Callback* obj)"
+// call: "        obj->finalize();"
+// params: []
+extern "C"
+void
+    casadi__Callback__finalize(std::string ** err_msg, casadi::Callback* obj);
+void
+    casadi__Callback__finalize(std::string ** err_msg, casadi::Callback* obj){
+    try {
+
+        obj->finalize();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_forward" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_forward"
+// cWrapperName: "casadi__Callback__get_forward"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Callback__get_forward(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
+// call: "        casadi::Function ret = obj->get_forward(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Callback__get_forward(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2);
+casadi::Function*
+    casadi__Callback__get_forward(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
+
+        casadi::Function ret = obj->get_forward(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_jacobian" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_jacobian"
+// cWrapperName: "casadi__Callback__get_jacobian"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Callback__get_jacobian(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// call: "        casadi::Function ret = obj->get_jacobian(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Callback__get_jacobian(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
+casadi::Function*
+    casadi__Callback__get_jacobian(std::string ** err_msg, casadi::Callback* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
+
+        casadi::Function ret = obj->get_jacobian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_n_forward" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_n_forward"
+// cWrapperName: "casadi__Callback__get_n_forward"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Callback__get_n_forward(std::string ** err_msg, casadi::Callback* obj)"
+// call: "        int ret = obj->get_n_forward();"
+// params: []
+extern "C"
+int
+    casadi__Callback__get_n_forward(std::string ** err_msg, casadi::Callback* obj);
+int
+    casadi__Callback__get_n_forward(std::string ** err_msg, casadi::Callback* obj){
+    try {
+
+        int ret = obj->get_n_forward();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_n_in" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_n_in"
+// cWrapperName: "casadi__Callback__get_n_in"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Callback__get_n_in(std::string ** err_msg, casadi::Callback* obj)"
+// call: "        int ret = obj->get_n_in();"
+// params: []
+extern "C"
+int
+    casadi__Callback__get_n_in(std::string ** err_msg, casadi::Callback* obj);
+int
+    casadi__Callback__get_n_in(std::string ** err_msg, casadi::Callback* obj){
+    try {
+
+        int ret = obj->get_n_in();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_n_out" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_n_out"
+// cWrapperName: "casadi__Callback__get_n_out"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Callback__get_n_out(std::string ** err_msg, casadi::Callback* obj)"
+// call: "        int ret = obj->get_n_out();"
+// params: []
+extern "C"
+int
+    casadi__Callback__get_n_out(std::string ** err_msg, casadi::Callback* obj);
+int
+    casadi__Callback__get_n_out(std::string ** err_msg, casadi::Callback* obj){
+    try {
+
+        int ret = obj->get_n_out();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_n_reverse" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_n_reverse"
+// cWrapperName: "casadi__Callback__get_n_reverse"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Callback__get_n_reverse(std::string ** err_msg, casadi::Callback* obj)"
+// call: "        int ret = obj->get_n_reverse();"
+// params: []
+extern "C"
+int
+    casadi__Callback__get_n_reverse(std::string ** err_msg, casadi::Callback* obj);
+int
+    casadi__Callback__get_n_reverse(std::string ** err_msg, casadi::Callback* obj){
+    try {
+
+        int ret = obj->get_n_reverse();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_name_in" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_name_in"
+// cWrapperName: "casadi__Callback__get_name_in"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Callback__get_name_in(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// call: "        std::string ret = obj->get_name_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::string*
+    casadi__Callback__get_name_in(std::string ** err_msg, casadi::Callback* obj, int x0);
+std::string*
+    casadi__Callback__get_name_in(std::string ** err_msg, casadi::Callback* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::string ret = obj->get_name_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_name_out" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_name_out"
+// cWrapperName: "casadi__Callback__get_name_out"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Callback__get_name_out(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// call: "        std::string ret = obj->get_name_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::string*
+    casadi__Callback__get_name_out(std::string ** err_msg, casadi::Callback* obj, int x0);
+std::string*
+    casadi__Callback__get_name_out(std::string ** err_msg, casadi::Callback* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::string ret = obj->get_name_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_reverse" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_reverse"
+// cWrapperName: "casadi__Callback__get_reverse"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Callback__get_reverse(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
+// call: "        casadi::Function ret = obj->get_reverse(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Callback__get_reverse(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2);
+casadi::Function*
+    casadi__Callback__get_reverse(std::string ** err_msg, casadi::Callback* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
+
+        casadi::Function ret = obj->get_reverse(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_sparsity_in" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_sparsity_in"
+// cWrapperName: "casadi__Callback__get_sparsity_in"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Callback__get_sparsity_in(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->get_sparsity_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Callback__get_sparsity_in(std::string ** err_msg, casadi::Callback* obj, int x0);
+casadi::Sparsity*
+    casadi__Callback__get_sparsity_in(std::string ** err_msg, casadi::Callback* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->get_sparsity_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_sparsity_out" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::get_sparsity_out"
+// cWrapperName: "casadi__Callback__get_sparsity_out"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Callback__get_sparsity_out(std::string ** err_msg, casadi::Callback* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->get_sparsity_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Callback__get_sparsity_out(std::string ** err_msg, casadi::Callback* obj, int x0);
+casadi::Sparsity*
+    casadi__Callback__get_sparsity_out(std::string ** err_msg, casadi::Callback* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->get_sparsity_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_jacobian" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::has_jacobian"
+// cWrapperName: "casadi__Callback__has_jacobian"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Callback__has_jacobian(std::string ** err_msg, casadi::Callback* obj)"
+// call: "        bool ret = obj->has_jacobian();"
+// params: []
+extern "C"
+int
+    casadi__Callback__has_jacobian(std::string ** err_msg, casadi::Callback* obj);
+int
+    casadi__Callback__has_jacobian(std::string ** err_msg, casadi::Callback* obj){
+    try {
+
+        bool ret = obj->has_jacobian();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "init" ===============
+// class: "casadi::Callback"
+// cppName: "casadi::Callback::init"
+// cWrapperName: "casadi__Callback__init"
+// protoArgs: "(std::string ** err_msg, casadi::Callback* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Callback__init(std::string ** err_msg, casadi::Callback* obj)"
+// call: "        obj->init();"
+// params: []
+extern "C"
+void
+    casadi__Callback__init(std::string ** err_msg, casadi::Callback* obj);
+void
+    casadi__Callback__init(std::string ** err_msg, casadi::Callback* obj){
+    try {
+
+        obj->init();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "CasadiMeta")===============
+// classType: UserType (Namespace ["casadi"]) (Name "CasadiMeta")
+extern "C"
+void delete_casadi__CasadiMeta(casadi::CasadiMeta* obj);
+void delete_casadi__CasadiMeta(casadi::CasadiMeta* obj){
+    delete obj;
+}
+
+// ================== Static method: "getBuildType" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getBuildType"
+// cWrapperName: "casadi__CasadiMeta__getBuildType"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getBuildType(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getBuildType();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getBuildType(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getBuildType(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getBuildType();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getCompiler" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getCompiler"
+// cWrapperName: "casadi__CasadiMeta__getCompiler"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getCompiler(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getCompiler();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getCompiler(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getCompiler(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getCompiler();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getCompilerFlags" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getCompilerFlags"
+// cWrapperName: "casadi__CasadiMeta__getCompilerFlags"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getCompilerFlags();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getCompilerFlags();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getCompilerId" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getCompilerId"
+// cWrapperName: "casadi__CasadiMeta__getCompilerId"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getCompilerId(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getCompilerId();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getCompilerId(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getCompilerId(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getCompilerId();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getFeatureList" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getFeatureList"
+// cWrapperName: "casadi__CasadiMeta__getFeatureList"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getFeatureList(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getFeatureList();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getFeatureList(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getFeatureList(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getFeatureList();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getGitDescribe" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getGitDescribe"
+// cWrapperName: "casadi__CasadiMeta__getGitDescribe"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getGitDescribe(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getGitDescribe();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getGitDescribe(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getGitDescribe(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getGitDescribe();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getGitRevision" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getGitRevision"
+// cWrapperName: "casadi__CasadiMeta__getGitRevision"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getGitRevision(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getGitRevision();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getGitRevision(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getGitRevision(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getGitRevision();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getInstallPrefix" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getInstallPrefix"
+// cWrapperName: "casadi__CasadiMeta__getInstallPrefix"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getInstallPrefix(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getInstallPrefix();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getInstallPrefix(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getInstallPrefix(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getInstallPrefix();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getModules" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getModules"
+// cWrapperName: "casadi__CasadiMeta__getModules"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getModules(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getModules();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getModules(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getModules(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getModules();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getPlugins" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getPlugins"
+// cWrapperName: "casadi__CasadiMeta__getPlugins"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getPlugins(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getPlugins();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getPlugins(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getPlugins(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getPlugins();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getVersion" ===============
+// class: "casadi::CasadiMeta"
+// cppName: "casadi::CasadiMeta::getVersion"
+// cWrapperName: "casadi__CasadiMeta__getVersion"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CasadiMeta__getVersion(std::string ** err_msg)"
+// call: "        std::string ret = casadi::CasadiMeta::getVersion();"
+// params: []
+extern "C"
+std::string*
+    casadi__CasadiMeta__getVersion(std::string ** err_msg);
+std::string*
+    casadi__CasadiMeta__getVersion(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::CasadiMeta::getVersion();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "CodeGenerator")===============
+// classType: UserType (Namespace ["casadi"]) (Name "CodeGenerator")
+extern "C"
+void delete_casadi__CodeGenerator(casadi::CodeGenerator* obj);
+void delete_casadi__CodeGenerator(casadi::CodeGenerator* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator"
+// cWrapperName: "casadi__CodeGenerator__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "CodeGenerator")
+// cWrapperRetType: "casadi::CodeGenerator*"
+// proto: "casadi::CodeGenerator*\n    casadi__CodeGenerator__CONSTRUCTOR__0(std::string ** err_msg)"
+// call: "        casadi::CodeGenerator* ret = (casadi::CodeGenerator*)new casadi::CodeGenerator();"
+// params: []
+extern "C"
+casadi::CodeGenerator*
+    casadi__CodeGenerator__CONSTRUCTOR__0(std::string ** err_msg);
+casadi::CodeGenerator*
+    casadi__CodeGenerator__CONSTRUCTOR__0(std::string ** err_msg){
+    try {
+
+        casadi::CodeGenerator* ret = (casadi::CodeGenerator*)new casadi::CodeGenerator();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator"
+// cWrapperName: "casadi__CodeGenerator__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "CodeGenerator")
+// cWrapperRetType: "casadi::CodeGenerator*"
+// proto: "casadi::CodeGenerator*\n    casadi__CodeGenerator__CONSTRUCTOR__1(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
+// call: "        casadi::CodeGenerator* ret = (casadi::CodeGenerator*)new casadi::CodeGenerator(x0_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::CodeGenerator*
+    casadi__CodeGenerator__CONSTRUCTOR__1(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0);
+casadi::CodeGenerator*
+    casadi__CodeGenerator__CONSTRUCTOR__1(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0){
+    try {
+        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
+
+        casadi::CodeGenerator* ret = (casadi::CodeGenerator*)new casadi::CodeGenerator(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::add"
+// cWrapperName: "casadi__CodeGenerator__add"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__CodeGenerator__add(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0)"
+// call: "        obj->add(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+void
+    casadi__CodeGenerator__add(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0);
+void
+    casadi__CodeGenerator__add(std::string ** err_msg, casadi::CodeGenerator* obj, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        obj->add(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "addInclude" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::addInclude"
+// cWrapperName: "casadi__CodeGenerator__addInclude__0"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__CodeGenerator__addInclude__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
+// call: "        obj->addInclude(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__CodeGenerator__addInclude__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0);
+void
+    casadi__CodeGenerator__addInclude__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->addInclude(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "addInclude" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::addInclude"
+// cWrapperName: "casadi__CodeGenerator__addInclude__1"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__CodeGenerator__addInclude__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1)"
+// call: "        obj->addInclude(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__CodeGenerator__addInclude__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1);
+void
+    casadi__CodeGenerator__addInclude__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        obj->addInclude(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "addInclude" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::addInclude"
+// cWrapperName: "casadi__CodeGenerator__addInclude__2"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__CodeGenerator__addInclude__2(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2)"
+// call: "        obj->addInclude(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__CodeGenerator__addInclude__2(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2);
+void
+    casadi__CodeGenerator__addInclude__2(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, int x1, std::string* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        obj->addInclude(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "compile" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::compile"
+// cWrapperName: "casadi__CodeGenerator__compile__0"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CodeGenerator__compile__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
+// call: "        std::string ret = obj->compile(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::string*
+    casadi__CodeGenerator__compile__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0);
+std::string*
+    casadi__CodeGenerator__compile__0(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::string ret = obj->compile(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "compile" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::compile"
+// cWrapperName: "casadi__CodeGenerator__compile__1"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CodeGenerator__compile__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1)"
+// call: "        std::string ret = obj->compile(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::string*
+    casadi__CodeGenerator__compile__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1);
+std::string*
+    casadi__CodeGenerator__compile__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        std::string ret = obj->compile(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "generate" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::generate"
+// cWrapperName: "casadi__CodeGenerator__generate__0"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__CodeGenerator__generate__0(std::string ** err_msg, casadi::CodeGenerator* obj)"
+// call: "        std::string ret = obj->generate();"
+// params: []
+extern "C"
+std::string*
+    casadi__CodeGenerator__generate__0(std::string ** err_msg, casadi::CodeGenerator* obj);
+std::string*
+    casadi__CodeGenerator__generate__0(std::string ** err_msg, casadi::CodeGenerator* obj){
+    try {
+
+        std::string ret = obj->generate();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "generate" ===============
+// class: "casadi::CodeGenerator"
+// cppName: "casadi::CodeGenerator::generate"
+// cWrapperName: "casadi__CodeGenerator__generate__1"
+// protoArgs: "(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__CodeGenerator__generate__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0)"
+// call: "        obj->generate(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__CodeGenerator__generate__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0);
+void
+    casadi__CodeGenerator__generate__1(std::string ** err_msg, casadi::CodeGenerator* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->generate(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "Compiler")===============
+// classType: UserType (Namespace ["casadi"]) (Name "Compiler")
+extern "C"
+void delete_casadi__Compiler(casadi::Compiler* obj);
+void delete_casadi__Compiler(casadi::Compiler* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Compiler"
+// cppName: "casadi::Compiler"
+// cWrapperName: "casadi__Compiler__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Compiler")
+// cWrapperRetType: "casadi::Compiler*"
+// proto: "casadi::Compiler*\n    casadi__Compiler__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1)"
+// call: "        casadi::Compiler* ret = (casadi::Compiler*)new casadi::Compiler(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Compiler*
+    casadi__Compiler__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1);
+casadi::Compiler*
+    casadi__Compiler__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Compiler* ret = (casadi::Compiler*)new casadi::Compiler(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Compiler"
+// cppName: "casadi::Compiler"
+// cWrapperName: "casadi__Compiler__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Compiler")
+// cWrapperRetType: "casadi::Compiler*"
+// proto: "casadi::Compiler*\n    casadi__Compiler__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2)"
+// call: "        casadi::Compiler* ret = (casadi::Compiler*)new casadi::Compiler(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Compiler*
+    casadi__Compiler__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2);
+casadi::Compiler*
+    casadi__Compiler__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1, std::map< std::string, casadi::GenericType* >* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
+
+        casadi::Compiler* ret = (casadi::Compiler*)new casadi::Compiler(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Compiler"
+// cppName: "casadi::Compiler"
+// cWrapperName: "casadi__Compiler__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Compiler")
+// cWrapperRetType: "casadi::Compiler*"
+// proto: "casadi::Compiler*\n    casadi__Compiler__CONSTRUCTOR__2(std::string ** err_msg)"
+// call: "        casadi::Compiler* ret = (casadi::Compiler*)new casadi::Compiler();"
+// params: []
+extern "C"
+casadi::Compiler*
+    casadi__Compiler__CONSTRUCTOR__2(std::string ** err_msg);
+casadi::Compiler*
+    casadi__Compiler__CONSTRUCTOR__2(std::string ** err_msg){
+    try {
+
+        casadi::Compiler* ret = (casadi::Compiler*)new casadi::Compiler();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "doc" ===============
+// class: "casadi::Compiler"
+// cppName: "casadi::Compiler::doc"
+// cWrapperName: "casadi__Compiler__doc"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Compiler__doc(std::string ** err_msg, std::string* x0)"
+// call: "        std::string ret = casadi::Compiler::doc(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::string*
+    casadi__Compiler__doc(std::string ** err_msg, std::string* x0);
+std::string*
+    casadi__Compiler__doc(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::string ret = casadi::Compiler::doc(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hasPlugin" ===============
+// class: "casadi::Compiler"
+// cppName: "casadi::Compiler::hasPlugin"
+// cWrapperName: "casadi__Compiler__hasPlugin"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Compiler__hasPlugin(std::string ** err_msg, std::string* x0)"
+// call: "        bool ret = casadi::Compiler::hasPlugin(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Compiler__hasPlugin(std::string ** err_msg, std::string* x0);
+int
+    casadi__Compiler__hasPlugin(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        bool ret = casadi::Compiler::hasPlugin(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "loadPlugin" ===============
+// class: "casadi::Compiler"
+// cppName: "casadi::Compiler::loadPlugin"
+// cWrapperName: "casadi__Compiler__loadPlugin"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Compiler__loadPlugin(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::Compiler::loadPlugin(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Compiler__loadPlugin(std::string ** err_msg, std::string* x0);
+void
+    casadi__Compiler__loadPlugin(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Compiler::loadPlugin(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "plugin_name" ===============
+// class: "casadi::Compiler"
+// cppName: "casadi::Compiler::plugin_name"
+// cWrapperName: "casadi__Compiler__plugin_name"
+// protoArgs: "(std::string ** err_msg, casadi::Compiler* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Compiler__plugin_name(std::string ** err_msg, casadi::Compiler* obj)"
+// call: "        std::string ret = obj->plugin_name();"
+// params: []
+extern "C"
+std::string*
+    casadi__Compiler__plugin_name(std::string ** err_msg, casadi::Compiler* obj);
+std::string*
+    casadi__Compiler__plugin_name(std::string ** err_msg, casadi::Compiler* obj){
+    try {
+
+        std::string ret = obj->plugin_name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "DM")===============
+// classType: UserType (Namespace ["casadi"]) (Name "DM")
+extern "C"
+void delete_casadi__DM(casadi::DM* obj);
+void delete_casadi__DM(casadi::DM* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::vector< casadi::SXElem* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SXElem* >* x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElem")))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SXElem* >* x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SXElem* >* x0){
+    try {
+        std::vector< casadi::SXElem > x0_ = Marshaling<std::vector< casadi::SXElem >,std::vector< casadi::SXElem* >*>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__1(std::string ** err_msg, casadi::SX* x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__1(std::string ** err_msg, casadi::SX* x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__1(std::string ** err_msg, casadi::SX* x0){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, casadi::IM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__3(std::string ** err_msg, casadi::IM* x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__3(std::string ** err_msg, casadi::IM* x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__3(std::string ** err_msg, casadi::IM* x0){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__4"
+// protoArgs: "(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(Ref (Const (StdVec (StdVec CDouble))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0){
+    try {
+        std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__5"
+// protoArgs: "(std::string ** err_msg, double x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__5(std::string ** err_msg, double x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(CDouble,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__5(std::string ** err_msg, double x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__5(std::string ** err_msg, double x0){
+    try {
+        double x0_ = Marshaling<double,double>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__6"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::DM* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::DM* x1)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::DM* x1);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::DM* x1){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        casadi::DM& x1_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x1);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__7"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__8"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__9"
+// protoArgs: "(std::string ** err_msg, casadi::DM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__9(std::string ** err_msg, casadi::DM* x0)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__9(std::string ** err_msg, casadi::DM* x0);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__9(std::string ** err_msg, casadi::DM* x0){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM"
+// cWrapperName: "casadi__DM__CONSTRUCTOR__10"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__CONSTRUCTOR__10(std::string ** err_msg)"
+// call: "        casadi::DM* ret = (casadi::DM*)new casadi::DM();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__10(std::string ** err_msg);
+casadi::DM*
+    casadi__DM__CONSTRUCTOR__10(std::string ** err_msg){
+    try {
+
+        casadi::DM* ret = (casadi::DM*)new casadi::DM();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "T" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::T"
+// cWrapperName: "casadi__DM__T"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__T(std::string ** err_msg, casadi::DM* obj)"
+// call: "        casadi::DM ret = obj->T();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__T(std::string ** err_msg, casadi::DM* obj);
+casadi::DM*
+    casadi__DM__T(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        casadi::DM ret = obj->T();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "__nonzero__" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::__nonzero__"
+// cWrapperName: "casadi__DM____nonzero__"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM____nonzero__(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->__nonzero__();"
+// params: []
+extern "C"
+int
+    casadi__DM____nonzero__(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM____nonzero__(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->__nonzero__();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "binary" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::binary"
+// cWrapperName: "casadi__DM__binary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__binary(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// call: "        casadi::DM ret = casadi::DM::binary(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__binary(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2);
+casadi::DM*
+    casadi__DM__binary(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::DM& x1_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x1);
+        casadi::DM& x2_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::binary(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "clear" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::clear"
+// cWrapperName: "casadi__DM__clear"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__clear(std::string ** err_msg, casadi::DM* obj)"
+// call: "        obj->clear();"
+// params: []
+extern "C"
+void
+    casadi__DM__clear(std::string ** err_msg, casadi::DM* obj);
+void
+    casadi__DM__clear(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        obj->clear();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "colind" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::colind"
+// cWrapperName: "casadi__DM__colind"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__colind(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        int ret = obj->colind(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__DM__colind(std::string ** err_msg, casadi::DM* obj, int x0);
+int
+    casadi__DM__colind(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->colind(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::dep"
+// cWrapperName: "casadi__DM__dep__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__dep__0(std::string ** err_msg, casadi::DM* obj)"
+// call: "        casadi::DM ret = obj->dep();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__dep__0(std::string ** err_msg, casadi::DM* obj);
+casadi::DM*
+    casadi__DM__dep__0(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        casadi::DM ret = obj->dep();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::dep"
+// cWrapperName: "casadi__DM__dep__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__dep__1(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        casadi::DM ret = obj->dep(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__dep__1(std::string ** err_msg, casadi::DM* obj, int x0);
+casadi::DM*
+    casadi__DM__dep__1(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM ret = obj->dep(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dim" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::dim"
+// cWrapperName: "casadi__DM__dim"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DM__dim(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::string ret = obj->dim();"
+// params: []
+extern "C"
+std::string*
+    casadi__DM__dim(std::string ** err_msg, casadi::DM* obj);
+std::string*
+    casadi__DM__dim(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::string ret = obj->dim();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "element_hash" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::element_hash"
+// cWrapperName: "casadi__DM__element_hash"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__DM__element_hash(std::string ** err_msg, casadi::DM* obj)"
+// call: "        size_t ret = obj->element_hash();"
+// params: []
+extern "C"
+size_t
+    casadi__DM__element_hash(std::string ** err_msg, casadi::DM* obj);
+size_t
+    casadi__DM__element_hash(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        size_t ret = obj->element_hash();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::enlarge"
+// cWrapperName: "casadi__DM__enlarge__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__enlarge__0(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__enlarge__0(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+void
+    casadi__DM__enlarge__0(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        obj->enlarge(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::enlarge"
+// cWrapperName: "casadi__DM__enlarge__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__enlarge__1(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_, x4_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__enlarge__1(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
+void
+    casadi__DM__enlarge__1(std::string ** err_msg, casadi::DM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::erase"
+// cWrapperName: "casadi__DM__erase__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__erase__0(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0)"
+// call: "        obj->erase(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__erase__0(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0);
+void
+    casadi__DM__erase__0(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        obj->erase(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::erase"
+// cWrapperName: "casadi__DM__erase__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__erase__1(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, int x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__erase__1(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, int x1);
+void
+    casadi__DM__erase__1(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, int x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::erase"
+// cWrapperName: "casadi__DM__erase__2"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__erase__2(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__erase__2(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1);
+void
+    casadi__DM__erase__2(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::erase"
+// cWrapperName: "casadi__DM__erase__3"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__erase__3(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// call: "        obj->erase(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__erase__3(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
+void
+    casadi__DM__erase__3(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->erase(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "eye" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::eye"
+// cWrapperName: "casadi__DM__eye"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__eye(std::string ** err_msg, int x0)"
+// call: "        casadi::DM ret = casadi::DM::eye(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__eye(std::string ** err_msg, int x0);
+casadi::DM*
+    casadi__DM__eye(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::eye(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get"
+// cWrapperName: "casadi__DM__get__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get__0(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get__0(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__DM__get__0(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get"
+// cWrapperName: "casadi__DM__get__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get__1(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get__1(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__DM__get__1(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get"
+// cWrapperName: "casadi__DM__get__2"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get__2(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get__2(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__DM__get__2(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get"
+// cWrapperName: "casadi__DM__get__3"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get__3(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get__3(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__DM__get__3(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get"
+// cWrapperName: "casadi__DM__get__4"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get__4(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get__4(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__DM__get__4(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get"
+// cWrapperName: "casadi__DM__get__5"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get__5(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get__5(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2);
+void
+    casadi__DM__get__5(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get"
+// cWrapperName: "casadi__DM__get__6"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get__6(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get__6(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2);
+void
+    casadi__DM__get__6(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "getEqualityCheckingDepth" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::getEqualityCheckingDepth"
+// cWrapperName: "casadi__DM__getEqualityCheckingDepth"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__getEqualityCheckingDepth(std::string ** err_msg)"
+// call: "        int ret = casadi::DM::getEqualityCheckingDepth();"
+// params: []
+extern "C"
+int
+    casadi__DM__getEqualityCheckingDepth(std::string ** err_msg);
+int
+    casadi__DM__getEqualityCheckingDepth(std::string ** err_msg){
+    try {
+
+        int ret = casadi::DM::getEqualityCheckingDepth();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_colind" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get_colind"
+// cWrapperName: "casadi__DM__get_colind"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__DM__get_colind(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::vector< int > ret = obj->get_colind();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__DM__get_colind(std::string ** err_msg, casadi::DM* obj);
+std::vector< int >*
+    casadi__DM__get_colind(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::vector< int > ret = obj->get_colind();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "get_input" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get_input"
+// cWrapperName: "casadi__DM__get_input"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DM"))
+// cWrapperRetType: "std::vector< casadi::DM* >*"
+// proto: "std::vector< casadi::DM* >*\n    casadi__DM__get_input(std::string ** err_msg, casadi::Function* x0)"
+// call: "        std::vector< casadi::DM > ret = casadi::DM::get_input(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+std::vector< casadi::DM* >*
+    casadi__DM__get_input(std::string ** err_msg, casadi::Function* x0);
+std::vector< casadi::DM* >*
+    casadi__DM__get_input(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        std::vector< casadi::DM > ret = casadi::DM::get_input(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nonzeros" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get_nonzeros"
+// cWrapperName: "casadi__DM__get_nonzeros"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DM__get_nonzeros(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::vector< double > ret = obj->get_nonzeros();"
+// params: []
+extern "C"
+std::vector< double >*
+    casadi__DM__get_nonzeros(std::string ** err_msg, casadi::DM* obj);
+std::vector< double >*
+    casadi__DM__get_nonzeros(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::vector< double > ret = obj->get_nonzeros();
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get_nz"
+// cWrapperName: "casadi__DM__get_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get_nz__0(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get_nz__0(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2);
+void
+    casadi__DM__get_nz__0(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get_nz"
+// cWrapperName: "casadi__DM__get_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__get_nz__1(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "DM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__get_nz__1(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2);
+void
+    casadi__DM__get_nz__1(std::string ** err_msg, casadi::DM* obj, casadi::DM** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::DM x0_ = casadi::DM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_row" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get_row"
+// cWrapperName: "casadi__DM__get_row"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__DM__get_row(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::vector< int > ret = obj->get_row();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__DM__get_row(std::string ** err_msg, casadi::DM* obj);
+std::vector< int >*
+    casadi__DM__get_row(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::vector< int > ret = obj->get_row();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_sparsity" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::get_sparsity"
+// cWrapperName: "casadi__DM__get_sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__DM__get_sparsity(std::string ** err_msg, casadi::DM* obj)"
+// call: "        casadi::Sparsity ret = obj->get_sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__DM__get_sparsity(std::string ** err_msg, casadi::DM* obj);
+casadi::Sparsity*
+    casadi__DM__get_sparsity(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        casadi::Sparsity ret = obj->get_sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::grad"
+// cWrapperName: "casadi__DM__grad__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::DM*
+    casadi__DM__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::grad"
+// cWrapperName: "casadi__DM__grad__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::DM*
+    casadi__DM__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::grad"
+// cWrapperName: "casadi__DM__grad__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::DM ret = casadi::DM::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::DM*
+    casadi__DM__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::grad"
+// cWrapperName: "casadi__DM__grad__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::DM*
+    casadi__DM__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::grad"
+// cWrapperName: "casadi__DM__grad__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__grad__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::DM ret = casadi::DM::grad(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__grad__4(std::string ** err_msg, casadi::Function* x0);
+casadi::DM*
+    casadi__DM__grad__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::grad(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::grad"
+// cWrapperName: "casadi__DM__grad__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__grad__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__grad__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::DM*
+    casadi__DM__grad__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::grad"
+// cWrapperName: "casadi__DM__grad__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::DM*
+    casadi__DM__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_duplicates" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::has_duplicates"
+// cWrapperName: "casadi__DM__has_duplicates"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__has_duplicates(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->has_duplicates();"
+// params: []
+extern "C"
+int
+    casadi__DM__has_duplicates(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__has_duplicates(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->has_duplicates();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_nz" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::has_nz"
+// cWrapperName: "casadi__DM__has_nz"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__has_nz(std::string ** err_msg, casadi::DM* obj, int x0, int x1)"
+// call: "        bool ret = obj->has_nz(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__DM__has_nz(std::string ** err_msg, casadi::DM* obj, int x0, int x1);
+int
+    casadi__DM__has_nz(std::string ** err_msg, casadi::DM* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        bool ret = obj->has_nz(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_zeros" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::has_zeros"
+// cWrapperName: "casadi__DM__has_zeros"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__has_zeros(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->has_zeros();"
+// params: []
+extern "C"
+int
+    casadi__DM__has_zeros(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__has_zeros(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->has_zeros();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::hess"
+// cWrapperName: "casadi__DM__hess__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::DM*
+    casadi__DM__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::hess"
+// cWrapperName: "casadi__DM__hess__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::DM*
+    casadi__DM__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::hess"
+// cWrapperName: "casadi__DM__hess__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::DM ret = casadi::DM::hess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::DM*
+    casadi__DM__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::hess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::hess"
+// cWrapperName: "casadi__DM__hess__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::DM*
+    casadi__DM__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::hess"
+// cWrapperName: "casadi__DM__hess__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__hess__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::DM ret = casadi::DM::hess(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__hess__4(std::string ** err_msg, casadi::Function* x0);
+casadi::DM*
+    casadi__DM__hess__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::hess(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::hess"
+// cWrapperName: "casadi__DM__hess__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__hess__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::hess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__hess__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::DM*
+    casadi__DM__hess__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::hess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::hess"
+// cWrapperName: "casadi__DM__hess__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::DM*
+    casadi__DM__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::inf"
+// cWrapperName: "casadi__DM__inf__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::DM ret = casadi::DM::inf(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::DM*
+    casadi__DM__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::inf"
+// cWrapperName: "casadi__DM__inf__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__inf__1(std::string ** err_msg)"
+// call: "        casadi::DM ret = casadi::DM::inf();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__inf__1(std::string ** err_msg);
+casadi::DM*
+    casadi__DM__inf__1(std::string ** err_msg){
+    try {
+
+        casadi::DM ret = casadi::DM::inf();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::inf"
+// cWrapperName: "casadi__DM__inf__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__inf__2(std::string ** err_msg, int x0)"
+// call: "        casadi::DM ret = casadi::DM::inf(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__inf__2(std::string ** err_msg, int x0);
+casadi::DM*
+    casadi__DM__inf__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::inf"
+// cWrapperName: "casadi__DM__inf__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__inf__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::inf(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__inf__3(std::string ** err_msg, int x0, int x1);
+casadi::DM*
+    casadi__DM__inf__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::inf(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::inf"
+// cWrapperName: "casadi__DM__inf__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::DM ret = casadi::DM::inf(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::DM*
+    casadi__DM__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_column" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_column"
+// cWrapperName: "casadi__DM__is_column"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_column(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_column();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_column(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_column(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_column();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_commutative" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_commutative"
+// cWrapperName: "casadi__DM__is_commutative"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_commutative(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_commutative();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_commutative(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_commutative(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_commutative();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_constant" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_constant"
+// cWrapperName: "casadi__DM__is_constant"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_constant(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_constant();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_constant(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_constant(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_constant();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_dense" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_dense"
+// cWrapperName: "casadi__DM__is_dense"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_dense(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_dense();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_dense(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_dense(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_dense();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_empty"
+// cWrapperName: "casadi__DM__is_empty__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_empty__0(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_empty();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_empty__0(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_empty__0(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_empty();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_empty"
+// cWrapperName: "casadi__DM__is_empty__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_empty__1(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        bool ret = obj->is_empty(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__DM__is_empty__1(std::string ** err_msg, casadi::DM* obj, int x0);
+int
+    casadi__DM__is_empty__1(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_empty(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_identity" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_identity"
+// cWrapperName: "casadi__DM__is_identity"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_identity(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_identity();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_identity(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_identity(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_identity();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_integer" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_integer"
+// cWrapperName: "casadi__DM__is_integer"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_integer(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_integer();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_integer(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_integer(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_integer();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_leaf" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_leaf"
+// cWrapperName: "casadi__DM__is_leaf"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_leaf(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_leaf();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_leaf(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_leaf(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_leaf();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_minus_one" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_minus_one"
+// cWrapperName: "casadi__DM__is_minus_one"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_minus_one(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_minus_one();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_minus_one(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_minus_one(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_minus_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_one" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_one"
+// cWrapperName: "casadi__DM__is_one"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_one(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_one();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_one(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_one(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_regular" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_regular"
+// cWrapperName: "casadi__DM__is_regular"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_regular(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_regular();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_regular(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_regular(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_regular();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_row" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_row"
+// cWrapperName: "casadi__DM__is_row"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_row(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_row();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_row(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_row(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_row();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_scalar"
+// cWrapperName: "casadi__DM__is_scalar__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_scalar__0(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_scalar();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_scalar__0(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_scalar__0(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_scalar();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_scalar"
+// cWrapperName: "casadi__DM__is_scalar__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_scalar__1(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        bool ret = obj->is_scalar(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__DM__is_scalar__1(std::string ** err_msg, casadi::DM* obj, int x0);
+int
+    casadi__DM__is_scalar__1(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_smooth" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_smooth"
+// cWrapperName: "casadi__DM__is_smooth"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_smooth(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_smooth();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_smooth(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_smooth(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_smooth();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_square" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_square"
+// cWrapperName: "casadi__DM__is_square"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_square(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_square();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_square(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_square(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_square();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_symbolic" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_symbolic"
+// cWrapperName: "casadi__DM__is_symbolic"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_symbolic(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_symbolic();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_symbolic(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_symbolic(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_symbolic();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_tril" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_tril"
+// cWrapperName: "casadi__DM__is_tril"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_tril(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_tril();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_tril(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_tril(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_tril();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_triu" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_triu"
+// cWrapperName: "casadi__DM__is_triu"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_triu(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_triu();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_triu(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_triu(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_triu();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_valid_input" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_valid_input"
+// cWrapperName: "casadi__DM__is_valid_input"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_valid_input(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_valid_input();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_valid_input(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_valid_input(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_valid_input();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_vector" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_vector"
+// cWrapperName: "casadi__DM__is_vector"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_vector(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_vector();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_vector(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_vector(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_zero" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::is_zero"
+// cWrapperName: "casadi__DM__is_zero"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__is_zero(std::string ** err_msg, casadi::DM* obj)"
+// call: "        bool ret = obj->is_zero();"
+// params: []
+extern "C"
+int
+    casadi__DM__is_zero(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__is_zero(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        bool ret = obj->is_zero();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::DM*
+    casadi__DM__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3);
+casadi::DM*
+    casadi__DM__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4);
+casadi::DM*
+    casadi__DM__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::DM*
+    casadi__DM__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3);
+casadi::DM*
+    casadi__DM__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4);
+casadi::DM*
+    casadi__DM__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::DM*
+    casadi__DM__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::DM*
+    casadi__DM__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3);
+casadi::DM*
+    casadi__DM__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4);
+casadi::DM*
+    casadi__DM__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__10"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__10(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__10(std::string ** err_msg, casadi::Function* x0);
+casadi::DM*
+    casadi__DM__jac__10(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::jac(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__11"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__11(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__11(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::DM*
+    casadi__DM__jac__11(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__12"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::DM*
+    casadi__DM__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__13"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3);
+casadi::DM*
+    casadi__DM__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::jac"
+// cWrapperName: "casadi__DM__jac__14"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// call: "        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4);
+casadi::DM*
+    casadi__DM__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::DM ret = casadi::DM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "matrix_matrix" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::matrix_matrix"
+// cWrapperName: "casadi__DM__matrix_matrix"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__matrix_matrix(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// call: "        casadi::DM ret = casadi::DM::matrix_matrix(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__matrix_matrix(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2);
+casadi::DM*
+    casadi__DM__matrix_matrix(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::DM& x1_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x1);
+        casadi::DM& x2_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::matrix_matrix(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "matrix_scalar" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::matrix_scalar"
+// cWrapperName: "casadi__DM__matrix_scalar"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__matrix_scalar(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// call: "        casadi::DM ret = casadi::DM::matrix_scalar(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__matrix_scalar(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2);
+casadi::DM*
+    casadi__DM__matrix_scalar(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::DM& x1_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x1);
+        casadi::DM& x2_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::matrix_scalar(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_dep" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::n_dep"
+// cWrapperName: "casadi__DM__n_dep"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__n_dep(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->n_dep();"
+// params: []
+extern "C"
+int
+    casadi__DM__n_dep(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__n_dep(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->n_dep();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::name"
+// cWrapperName: "casadi__DM__name"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DM__name(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::string ret = obj->name();"
+// params: []
+extern "C"
+std::string*
+    casadi__DM__name(std::string ** err_msg, casadi::DM* obj);
+std::string*
+    casadi__DM__name(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::string ret = obj->name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nan"
+// cWrapperName: "casadi__DM__nan__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::DM ret = casadi::DM::nan(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::DM*
+    casadi__DM__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nan"
+// cWrapperName: "casadi__DM__nan__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__nan__1(std::string ** err_msg)"
+// call: "        casadi::DM ret = casadi::DM::nan();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__nan__1(std::string ** err_msg);
+casadi::DM*
+    casadi__DM__nan__1(std::string ** err_msg){
+    try {
+
+        casadi::DM ret = casadi::DM::nan();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nan"
+// cWrapperName: "casadi__DM__nan__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__nan__2(std::string ** err_msg, int x0)"
+// call: "        casadi::DM ret = casadi::DM::nan(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__nan__2(std::string ** err_msg, int x0);
+casadi::DM*
+    casadi__DM__nan__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nan"
+// cWrapperName: "casadi__DM__nan__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__nan__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::nan(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__nan__3(std::string ** err_msg, int x0, int x1);
+casadi::DM*
+    casadi__DM__nan__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::nan(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nan"
+// cWrapperName: "casadi__DM__nan__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::DM ret = casadi::DM::nan(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::DM*
+    casadi__DM__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nnz"
+// cWrapperName: "casadi__DM__nnz"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__nnz(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->nnz();"
+// params: []
+extern "C"
+int
+    casadi__DM__nnz(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__nnz(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->nnz();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_diag" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nnz_diag"
+// cWrapperName: "casadi__DM__nnz_diag"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__nnz_diag(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->nnz_diag();"
+// params: []
+extern "C"
+int
+    casadi__DM__nnz_diag(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__nnz_diag(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->nnz_diag();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_lower" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nnz_lower"
+// cWrapperName: "casadi__DM__nnz_lower"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__nnz_lower(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->nnz_lower();"
+// params: []
+extern "C"
+int
+    casadi__DM__nnz_lower(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__nnz_lower(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->nnz_lower();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_upper" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::nnz_upper"
+// cWrapperName: "casadi__DM__nnz_upper"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__nnz_upper(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->nnz_upper();"
+// params: []
+extern "C"
+int
+    casadi__DM__nnz_upper(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__nnz_upper(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->nnz_upper();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::numel"
+// cWrapperName: "casadi__DM__numel__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__numel__0(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        int ret = obj->numel(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__DM__numel__0(std::string ** err_msg, casadi::DM* obj, int x0);
+int
+    casadi__DM__numel__0(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->numel(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::numel"
+// cWrapperName: "casadi__DM__numel__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__numel__1(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->numel();"
+// params: []
+extern "C"
+int
+    casadi__DM__numel__1(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__numel__1(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->numel();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::ones"
+// cWrapperName: "casadi__DM__ones__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::DM ret = casadi::DM::ones(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::DM*
+    casadi__DM__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::ones"
+// cWrapperName: "casadi__DM__ones__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::DM ret = casadi::DM::ones(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::DM*
+    casadi__DM__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::ones"
+// cWrapperName: "casadi__DM__ones__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__ones__2(std::string ** err_msg)"
+// call: "        casadi::DM ret = casadi::DM::ones();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__ones__2(std::string ** err_msg);
+casadi::DM*
+    casadi__DM__ones__2(std::string ** err_msg){
+    try {
+
+        casadi::DM ret = casadi::DM::ones();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::ones"
+// cWrapperName: "casadi__DM__ones__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__ones__3(std::string ** err_msg, int x0)"
+// call: "        casadi::DM ret = casadi::DM::ones(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__ones__3(std::string ** err_msg, int x0);
+casadi::DM*
+    casadi__DM__ones__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::ones"
+// cWrapperName: "casadi__DM__ones__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__ones__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::ones(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__ones__4(std::string ** err_msg, int x0, int x1);
+casadi::DM*
+    casadi__DM__ones__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::ones(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator +" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::operator +"
+// cWrapperName: "casadi__DM__operator__plus"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__operator__plus(std::string ** err_msg, casadi::DM* obj)"
+// call: "        casadi::DM ret = obj->operator +();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__operator__plus(std::string ** err_msg, casadi::DM* obj);
+casadi::DM*
+    casadi__DM__operator__plus(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        casadi::DM ret = obj->operator +();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator -" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::operator -"
+// cWrapperName: "casadi__DM__operator__minus"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__operator__minus(std::string ** err_msg, casadi::DM* obj)"
+// call: "        casadi::DM ret = obj->operator -();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__operator__minus(std::string ** err_msg, casadi::DM* obj);
+casadi::DM*
+    casadi__DM__operator__minus(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        casadi::DM ret = obj->operator -();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator double" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::operator double"
+// cWrapperName: "casadi__DM__operator_double"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DM__operator_double(std::string ** err_msg, casadi::DM* obj)"
+// call: "        double ret = obj->operator double();"
+// params: []
+extern "C"
+double
+    casadi__DM__operator_double(std::string ** err_msg, casadi::DM* obj);
+double
+    casadi__DM__operator_double(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        double ret = obj->operator double();
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator int" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::operator int"
+// cWrapperName: "casadi__DM__operator_int"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__operator_int(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->operator int();"
+// params: []
+extern "C"
+int
+    casadi__DM__operator_int(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__operator_int(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->operator int();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "print_dense" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::print_dense"
+// cWrapperName: "casadi__DM__print_dense"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__print_dense(std::string ** err_msg, casadi::DM* obj)"
+// call: "        obj->print_dense();"
+// params: []
+extern "C"
+void
+    casadi__DM__print_dense(std::string ** err_msg, casadi::DM* obj);
+void
+    casadi__DM__print_dense(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        obj->print_dense();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_scalar" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::print_scalar"
+// cWrapperName: "casadi__DM__print_scalar"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__print_scalar(std::string ** err_msg, casadi::DM* obj)"
+// call: "        obj->print_scalar();"
+// params: []
+extern "C"
+void
+    casadi__DM__print_scalar(std::string ** err_msg, casadi::DM* obj);
+void
+    casadi__DM__print_scalar(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        obj->print_scalar();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_sparse" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::print_sparse"
+// cWrapperName: "casadi__DM__print_sparse"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__print_sparse(std::string ** err_msg, casadi::DM* obj)"
+// call: "        obj->print_sparse();"
+// params: []
+extern "C"
+void
+    casadi__DM__print_sparse(std::string ** err_msg, casadi::DM* obj);
+void
+    casadi__DM__print_sparse(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        obj->print_sparse();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_split" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::print_split"
+// cWrapperName: "casadi__DM__print_split"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__print_split(std::string ** err_msg, casadi::DM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1)"
+// call: "        obj->print_split(x0_, x1_);"
+// params: [(Ref (StdVec StdString),SwigOutput True),(Ref (StdVec StdString),SwigOutput True)]
+extern "C"
+void
+    casadi__DM__print_split(std::string ** err_msg, casadi::DM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1);
+void
+    casadi__DM__print_split(std::string ** err_msg, casadi::DM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1){
+    try {
+        std::vector< std::string > x0_ = std::vector< std::string >();  // Swig output
+        std::vector< std::string > x1_ = std::vector< std::string >();  // Swig output
+
+        obj->print_split(x0_, x1_);
+        *x0 = WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_vector" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::print_vector"
+// cWrapperName: "casadi__DM__print_vector"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__print_vector(std::string ** err_msg, casadi::DM* obj)"
+// call: "        obj->print_vector();"
+// params: []
+extern "C"
+void
+    casadi__DM__print_vector(std::string ** err_msg, casadi::DM* obj);
+void
+    casadi__DM__print_vector(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        obj->print_vector();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "printme" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::printme"
+// cWrapperName: "casadi__DM__printme"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__printme(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0)"
+// call: "        casadi::DM ret = obj->printme(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__printme(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0);
+casadi::DM*
+    casadi__DM__printme(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+
+        casadi::DM ret = obj->printme(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "remove" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::remove"
+// cWrapperName: "casadi__DM__remove"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__remove(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        obj->remove(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__remove(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1);
+void
+    casadi__DM__remove(std::string ** err_msg, casadi::DM* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->remove(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reserve" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::reserve"
+// cWrapperName: "casadi__DM__reserve__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__reserve__0(std::string ** err_msg, casadi::DM* obj, int x0, int x1)"
+// call: "        obj->reserve(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__reserve__0(std::string ** err_msg, casadi::DM* obj, int x0, int x1);
+void
+    casadi__DM__reserve__0(std::string ** err_msg, casadi::DM* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->reserve(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reserve" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::reserve"
+// cWrapperName: "casadi__DM__reserve__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__reserve__1(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        obj->reserve(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__reserve__1(std::string ** err_msg, casadi::DM* obj, int x0);
+void
+    casadi__DM__reserve__1(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        obj->reserve(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "resetInput" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::resetInput"
+// cWrapperName: "casadi__DM__resetInput"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__resetInput(std::string ** err_msg, casadi::DM* obj)"
+// call: "        obj->resetInput();"
+// params: []
+extern "C"
+void
+    casadi__DM__resetInput(std::string ** err_msg, casadi::DM* obj);
+void
+    casadi__DM__resetInput(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        obj->resetInput();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "resize" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::resize"
+// cWrapperName: "casadi__DM__resize"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__resize(std::string ** err_msg, casadi::DM* obj, int x0, int x1)"
+// call: "        obj->resize(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__resize(std::string ** err_msg, casadi::DM* obj, int x0, int x1);
+void
+    casadi__DM__resize(std::string ** err_msg, casadi::DM* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->resize(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "row" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::row"
+// cWrapperName: "casadi__DM__row"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__row(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        int ret = obj->row(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__DM__row(std::string ** err_msg, casadi::DM* obj, int x0);
+int
+    casadi__DM__row(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->row(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sanity_check"
+// cWrapperName: "casadi__DM__sanity_check__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__sanity_check__0(std::string ** err_msg, casadi::DM* obj)"
+// call: "        obj->sanity_check();"
+// params: []
+extern "C"
+void
+    casadi__DM__sanity_check__0(std::string ** err_msg, casadi::DM* obj);
+void
+    casadi__DM__sanity_check__0(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        obj->sanity_check();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sanity_check"
+// cWrapperName: "casadi__DM__sanity_check__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__sanity_check__1(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        obj->sanity_check(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__sanity_check__1(std::string ** err_msg, casadi::DM* obj, int x0);
+void
+    casadi__DM__sanity_check__1(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        obj->sanity_check(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "scalar_matrix" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::scalar_matrix"
+// cWrapperName: "casadi__DM__scalar_matrix"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__scalar_matrix(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2)"
+// call: "        casadi::DM ret = casadi::DM::scalar_matrix(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__scalar_matrix(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2);
+casadi::DM*
+    casadi__DM__scalar_matrix(std::string ** err_msg, int x0, casadi::DM* x1, casadi::DM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::DM& x1_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x1);
+        casadi::DM& x2_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::scalar_matrix(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set"
+// cWrapperName: "casadi__DM__set__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set__0(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set__0(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__DM__set__0(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set"
+// cWrapperName: "casadi__DM__set__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set__1(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set__1(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__DM__set__1(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set"
+// cWrapperName: "casadi__DM__set__2"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set__2(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set__2(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__DM__set__2(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set"
+// cWrapperName: "casadi__DM__set__3"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set__3(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set__3(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__DM__set__3(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set"
+// cWrapperName: "casadi__DM__set__4"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set__4(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set__4(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__DM__set__4(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set"
+// cWrapperName: "casadi__DM__set__5"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set__5(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set__5(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2);
+void
+    casadi__DM__set__5(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set"
+// cWrapperName: "casadi__DM__set__6"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set__6(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set__6(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2);
+void
+    casadi__DM__set__6(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::setEqualityCheckingDepth"
+// cWrapperName: "casadi__DM__setEqualityCheckingDepth__0"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__setEqualityCheckingDepth__0(std::string ** err_msg)"
+// call: "        casadi::DM::setEqualityCheckingDepth();"
+// params: []
+extern "C"
+void
+    casadi__DM__setEqualityCheckingDepth__0(std::string ** err_msg);
+void
+    casadi__DM__setEqualityCheckingDepth__0(std::string ** err_msg){
+    try {
+
+        casadi::DM::setEqualityCheckingDepth();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::setEqualityCheckingDepth"
+// cWrapperName: "casadi__DM__setEqualityCheckingDepth__1"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
+// call: "        casadi::DM::setEqualityCheckingDepth(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
+void
+    casadi__DM__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM::setEqualityCheckingDepth(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setPrecision" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::setPrecision"
+// cWrapperName: "casadi__DM__setPrecision"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__setPrecision(std::string ** err_msg, int x0)"
+// call: "        casadi::DM::setPrecision(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__setPrecision(std::string ** err_msg, int x0);
+void
+    casadi__DM__setPrecision(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM::setPrecision(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setScientific" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::setScientific"
+// cWrapperName: "casadi__DM__setScientific"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__setScientific(std::string ** err_msg, int x0)"
+// call: "        casadi::DM::setScientific(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__setScientific(std::string ** err_msg, int x0);
+void
+    casadi__DM__setScientific(std::string ** err_msg, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::DM::setScientific(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setWidth" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::setWidth"
+// cWrapperName: "casadi__DM__setWidth"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__setWidth(std::string ** err_msg, int x0)"
+// call: "        casadi::DM::setWidth(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__DM__setWidth(std::string ** err_msg, int x0);
+void
+    casadi__DM__setWidth(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM::setWidth(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set_nz"
+// cWrapperName: "casadi__DM__set_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set_nz__0(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set_nz__0(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2);
+void
+    casadi__DM__set_nz__0(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::set_nz"
+// cWrapperName: "casadi__DM__set_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DM__set_nz__1(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DM__set_nz__1(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2);
+void
+    casadi__DM__set_nz__1(std::string ** err_msg, casadi::DM* obj, casadi::DM* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::size"
+// cWrapperName: "casadi__DM__size__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__size__0(std::string ** err_msg, casadi::DM* obj, int x0)"
+// call: "        int ret = obj->size(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__DM__size__0(std::string ** err_msg, casadi::DM* obj, int x0);
+int
+    casadi__DM__size__0(std::string ** err_msg, casadi::DM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::size"
+// cWrapperName: "casadi__DM__size__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__DM__size__1(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::pair< int, int > ret = obj->size();"
+// params: []
+extern "C"
+std::pair< int, int >*
+    casadi__DM__size__1(std::string ** err_msg, casadi::DM* obj);
+std::pair< int, int >*
+    casadi__DM__size__1(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::pair< int, int > ret = obj->size();
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::size1"
+// cWrapperName: "casadi__DM__size1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__size1(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->size1();"
+// params: []
+extern "C"
+int
+    casadi__DM__size1(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__size1(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->size1();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::size2"
+// cWrapperName: "casadi__DM__size2"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__DM__size2(std::string ** err_msg, casadi::DM* obj)"
+// call: "        int ret = obj->size2();"
+// params: []
+extern "C"
+int
+    casadi__DM__size2(std::string ** err_msg, casadi::DM* obj);
+int
+    casadi__DM__size2(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        int ret = obj->size2();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sparsity"
+// cWrapperName: "casadi__DM__sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__DM__sparsity(std::string ** err_msg, casadi::DM* obj)"
+// call: "        casadi::Sparsity ret = obj->sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__DM__sparsity(std::string ** err_msg, casadi::DM* obj);
+casadi::Sparsity*
+    casadi__DM__sparsity(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        casadi::Sparsity ret = obj->sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))
+// cWrapperRetType: "std::vector< std::vector< casadi::DM* >* >*"
+// proto: "std::vector< std::vector< casadi::DM* >* >*\n    casadi__DM__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// call: "        std::vector< std::vector< casadi::DM > > ret = casadi::DM::sym(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::DM* >* >*
+    casadi__DM__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
+std::vector< std::vector< casadi::DM* >* >*
+    casadi__DM__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        int x4_ = Marshaling<int,int>::marshal(x4);
+
+        std::vector< std::vector< casadi::DM > > ret = casadi::DM::sym(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))
+// cWrapperRetType: "std::vector< std::vector< casadi::DM* >* >*"
+// proto: "std::vector< std::vector< casadi::DM* >* >*\n    casadi__DM__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// call: "        std::vector< std::vector< casadi::DM > > ret = casadi::DM::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::DM* >* >*
+    casadi__DM__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
+std::vector< std::vector< casadi::DM* >* >*
+    casadi__DM__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< std::vector< casadi::DM > > ret = casadi::DM::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__2"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DM"))
+// cWrapperRetType: "std::vector< casadi::DM* >*"
+// proto: "std::vector< casadi::DM* >*\n    casadi__DM__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// call: "        std::vector< casadi::DM > ret = casadi::DM::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::DM* >*
+    casadi__DM__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
+std::vector< casadi::DM* >*
+    casadi__DM__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< casadi::DM > ret = casadi::DM::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__3"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DM"))
+// cWrapperRetType: "std::vector< casadi::DM* >*"
+// proto: "std::vector< casadi::DM* >*\n    casadi__DM__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// call: "        std::vector< casadi::DM > ret = casadi::DM::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::DM* >*
+    casadi__DM__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
+std::vector< casadi::DM* >*
+    casadi__DM__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        std::vector< casadi::DM > ret = casadi::DM::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__4"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// call: "        casadi::DM ret = casadi::DM::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
+casadi::DM*
+    casadi__DM__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__5"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// call: "        casadi::DM ret = casadi::DM::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
+casadi::DM*
+    casadi__DM__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__6"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__sym__6(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::DM ret = casadi::DM::sym(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__sym__6(std::string ** err_msg, std::string* x0);
+casadi::DM*
+    casadi__DM__sym__6(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::sym(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__7"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__sym__7(std::string ** err_msg, std::string* x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__sym__7(std::string ** err_msg, std::string* x0, int x1);
+casadi::DM*
+    casadi__DM__sym__7(std::string ** err_msg, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::sym"
+// cWrapperName: "casadi__DM__sym__8"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
+casadi::DM*
+    casadi__DM__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::tang"
+// cWrapperName: "casadi__DM__tang__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::DM*
+    casadi__DM__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::tang"
+// cWrapperName: "casadi__DM__tang__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::DM*
+    casadi__DM__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::tang"
+// cWrapperName: "casadi__DM__tang__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::DM ret = casadi::DM::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::DM*
+    casadi__DM__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::tang"
+// cWrapperName: "casadi__DM__tang__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::DM*
+    casadi__DM__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::tang"
+// cWrapperName: "casadi__DM__tang__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__tang__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::DM ret = casadi::DM::tang(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__tang__4(std::string ** err_msg, casadi::Function* x0);
+casadi::DM*
+    casadi__DM__tang__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::tang(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::tang"
+// cWrapperName: "casadi__DM__tang__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__tang__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__tang__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::DM*
+    casadi__DM__tang__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::tang"
+// cWrapperName: "casadi__DM__tang__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::DM*
+    casadi__DM__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::triplet"
+// cWrapperName: "casadi__DM__triplet__0"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, std::pair< int, int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, std::pair< int, int >* x3)"
+// call: "        casadi::DM ret = casadi::DM::triplet(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, std::pair< int, int >* x3);
+casadi::DM*
+    casadi__DM__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, std::pair< int, int >* x3){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::DM& x2_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x2);
+        std::pair< int, int > x3_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x3);
+
+        casadi::DM ret = casadi::DM::triplet(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::triplet"
+// cWrapperName: "casadi__DM__triplet__1"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, int x3, int x4)"
+// call: "        casadi::DM ret = casadi::DM::triplet(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, int x3, int x4);
+casadi::DM*
+    casadi__DM__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2, int x3, int x4){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::DM& x2_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        int x4_ = Marshaling<int,int>::marshal(x4);
+
+        casadi::DM ret = casadi::DM::triplet(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::triplet"
+// cWrapperName: "casadi__DM__triplet__2"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2)"
+// call: "        casadi::DM ret = casadi::DM::triplet(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2);
+casadi::DM*
+    casadi__DM__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::DM* x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::DM& x2_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x2);
+
+        casadi::DM ret = casadi::DM::triplet(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "type_name" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::type_name"
+// cWrapperName: "casadi__DM__type_name"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DM__type_name(std::string ** err_msg)"
+// call: "        std::string ret = casadi::DM::type_name();"
+// params: []
+extern "C"
+std::string*
+    casadi__DM__type_name(std::string ** err_msg);
+std::string*
+    casadi__DM__type_name(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::DM::type_name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "unary" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::unary"
+// cWrapperName: "casadi__DM__unary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::DM* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__unary(std::string ** err_msg, int x0, casadi::DM* x1)"
+// call: "        casadi::DM ret = casadi::DM::unary(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__unary(std::string ** err_msg, int x0, casadi::DM* x1);
+casadi::DM*
+    casadi__DM__unary(std::string ** err_msg, int x0, casadi::DM* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::DM& x1_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::unary(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::zeros"
+// cWrapperName: "casadi__DM__zeros__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::DM ret = casadi::DM::zeros(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::DM*
+    casadi__DM__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::zeros"
+// cWrapperName: "casadi__DM__zeros__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::DM ret = casadi::DM::zeros(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::DM*
+    casadi__DM__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::zeros"
+// cWrapperName: "casadi__DM__zeros__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__zeros__2(std::string ** err_msg)"
+// call: "        casadi::DM ret = casadi::DM::zeros();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__DM__zeros__2(std::string ** err_msg);
+casadi::DM*
+    casadi__DM__zeros__2(std::string ** err_msg){
+    try {
+
+        casadi::DM ret = casadi::DM::zeros();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::zeros"
+// cWrapperName: "casadi__DM__zeros__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__zeros__3(std::string ** err_msg, int x0)"
+// call: "        casadi::DM ret = casadi::DM::zeros(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__zeros__3(std::string ** err_msg, int x0);
+casadi::DM*
+    casadi__DM__zeros__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::DM ret = casadi::DM::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::zeros"
+// cWrapperName: "casadi__DM__zeros__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__DM__zeros__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::DM ret = casadi::DM::zeros(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__DM__zeros__4(std::string ** err_msg, int x0, int x1);
+casadi::DM*
+    casadi__DM__zeros__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = casadi::DM::zeros(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::getRepresentation"
+// cWrapperName: "casadi__DM__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DM__getRepresentation(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__DM__getRepresentation(std::string ** err_msg, casadi::DM* obj);
+std::string*
+    casadi__DM__getRepresentation(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::DM"
+// cppName: "casadi::DM::getDescription"
+// cWrapperName: "casadi__DM__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::DM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DM__getDescription(std::string ** err_msg, casadi::DM* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__DM__getDescription(std::string ** err_msg, casadi::DM* obj);
+std::string*
+    casadi__DM__getDescription(std::string ** err_msg, casadi::DM* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "DaeBuilder")===============
+// classType: UserType (Namespace ["casadi"]) (Name "DaeBuilder")
+extern "C"
+void delete_casadi__DaeBuilder(casadi::DaeBuilder* obj);
+void delete_casadi__DaeBuilder(casadi::DaeBuilder* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder"
+// cWrapperName: "casadi__DaeBuilder__CONSTRUCTOR"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DaeBuilder")
+// cWrapperRetType: "casadi::DaeBuilder*"
+// proto: "casadi::DaeBuilder*\n    casadi__DaeBuilder__CONSTRUCTOR(std::string ** err_msg)"
+// call: "        casadi::DaeBuilder* ret = (casadi::DaeBuilder*)new casadi::DaeBuilder();"
+// params: []
+extern "C"
+casadi::DaeBuilder*
+    casadi__DaeBuilder__CONSTRUCTOR(std::string ** err_msg);
+casadi::DaeBuilder*
+    casadi__DaeBuilder__CONSTRUCTOR(std::string ** err_msg){
+    try {
+
+        casadi::DaeBuilder* ret = (casadi::DaeBuilder*)new casadi::DaeBuilder();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_alg" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_alg"
+// cWrapperName: "casadi__DaeBuilder__add_alg__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_alg__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        obj->add_alg(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_alg__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+void
+    casadi__DaeBuilder__add_alg__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        obj->add_alg(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_alg" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_alg"
+// cWrapperName: "casadi__DaeBuilder__add_alg__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_alg__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// call: "        obj->add_alg(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_alg__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
+void
+    casadi__DaeBuilder__add_alg__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        obj->add_alg(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_d" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_d"
+// cWrapperName: "casadi__DaeBuilder__add_d__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_d__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        casadi::MX ret = obj->add_d(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_d__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_d__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        casadi::MX ret = obj->add_d(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_d" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_d"
+// cWrapperName: "casadi__DaeBuilder__add_d__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_d__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// call: "        casadi::MX ret = obj->add_d(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_d__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
+casadi::MX*
+    casadi__DaeBuilder__add_d__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::MX ret = obj->add_d(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_dae" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_dae"
+// cWrapperName: "casadi__DaeBuilder__add_dae__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_dae__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        obj->add_dae(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_dae__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+void
+    casadi__DaeBuilder__add_dae__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        obj->add_dae(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_dae" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_dae"
+// cWrapperName: "casadi__DaeBuilder__add_dae__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_dae__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// call: "        obj->add_dae(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_dae__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
+void
+    casadi__DaeBuilder__add_dae__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        obj->add_dae(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_lc" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_lc"
+// cWrapperName: "casadi__DaeBuilder__add_lc"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_lc(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1)"
+// call: "        casadi::MX ret = obj->add_lc(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_lc(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1);
+casadi::MX*
+    casadi__DaeBuilder__add_lc(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);
+
+        casadi::MX ret = obj->add_lc(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_ode" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_ode"
+// cWrapperName: "casadi__DaeBuilder__add_ode__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_ode__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        obj->add_ode(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_ode__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+void
+    casadi__DaeBuilder__add_ode__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        obj->add_ode(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_ode" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_ode"
+// cWrapperName: "casadi__DaeBuilder__add_ode__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_ode__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// call: "        obj->add_ode(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_ode__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
+void
+    casadi__DaeBuilder__add_ode__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        obj->add_ode(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_p" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_p"
+// cWrapperName: "casadi__DaeBuilder__add_p__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_p__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        casadi::MX ret = obj->add_p();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_p__0(std::string ** err_msg, casadi::DaeBuilder* obj);
+casadi::MX*
+    casadi__DaeBuilder__add_p__0(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        casadi::MX ret = obj->add_p();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_p" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_p"
+// cWrapperName: "casadi__DaeBuilder__add_p__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_p__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->add_p(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_p__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_p__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->add_p(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_p" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_p"
+// cWrapperName: "casadi__DaeBuilder__add_p__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_p__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        casadi::MX ret = obj->add_p(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_p__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+casadi::MX*
+    casadi__DaeBuilder__add_p__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = obj->add_p(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_q" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_q"
+// cWrapperName: "casadi__DaeBuilder__add_q__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_q__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        casadi::MX ret = obj->add_q();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_q__0(std::string ** err_msg, casadi::DaeBuilder* obj);
+casadi::MX*
+    casadi__DaeBuilder__add_q__0(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        casadi::MX ret = obj->add_q();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_q" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_q"
+// cWrapperName: "casadi__DaeBuilder__add_q__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_q__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->add_q(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_q__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_q__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->add_q(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_q" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_q"
+// cWrapperName: "casadi__DaeBuilder__add_q__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_q__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        casadi::MX ret = obj->add_q(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_q__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+casadi::MX*
+    casadi__DaeBuilder__add_q__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = obj->add_q(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_quad" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_quad"
+// cWrapperName: "casadi__DaeBuilder__add_quad__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_quad__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        obj->add_quad(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_quad__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+void
+    casadi__DaeBuilder__add_quad__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        obj->add_quad(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_quad" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_quad"
+// cWrapperName: "casadi__DaeBuilder__add_quad__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_quad__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// call: "        obj->add_quad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_quad__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
+void
+    casadi__DaeBuilder__add_quad__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        obj->add_quad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_s" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_s"
+// cWrapperName: "casadi__DaeBuilder__add_s__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: StdPair (UserType (Namespace ["casadi"]) (Name "MX")) (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::pair< casadi::MX*, casadi::MX* >*"
+// proto: "std::pair< casadi::MX*, casadi::MX* >*\n    casadi__DaeBuilder__add_s__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        std::pair< casadi::MX, casadi::MX > ret = obj->add_s();"
+// params: []
+extern "C"
+std::pair< casadi::MX*, casadi::MX* >*
+    casadi__DaeBuilder__add_s__0(std::string ** err_msg, casadi::DaeBuilder* obj);
+std::pair< casadi::MX*, casadi::MX* >*
+    casadi__DaeBuilder__add_s__0(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        std::pair< casadi::MX, casadi::MX > ret = obj->add_s();
+
+        return WrapReturn< std::pair< casadi::MX*, casadi::MX* >*, std::pair< casadi::MX, casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_s" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_s"
+// cWrapperName: "casadi__DaeBuilder__add_s__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdPair (UserType (Namespace ["casadi"]) (Name "MX")) (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::pair< casadi::MX*, casadi::MX* >*"
+// proto: "std::pair< casadi::MX*, casadi::MX* >*\n    casadi__DaeBuilder__add_s__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        std::pair< casadi::MX, casadi::MX > ret = obj->add_s(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::pair< casadi::MX*, casadi::MX* >*
+    casadi__DaeBuilder__add_s__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+std::pair< casadi::MX*, casadi::MX* >*
+    casadi__DaeBuilder__add_s__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::pair< casadi::MX, casadi::MX > ret = obj->add_s(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::pair< casadi::MX*, casadi::MX* >*, std::pair< casadi::MX, casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_s" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_s"
+// cWrapperName: "casadi__DaeBuilder__add_s__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdPair (UserType (Namespace ["casadi"]) (Name "MX")) (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::pair< casadi::MX*, casadi::MX* >*"
+// proto: "std::pair< casadi::MX*, casadi::MX* >*\n    casadi__DaeBuilder__add_s__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        std::pair< casadi::MX, casadi::MX > ret = obj->add_s(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::pair< casadi::MX*, casadi::MX* >*
+    casadi__DaeBuilder__add_s__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+std::pair< casadi::MX*, casadi::MX* >*
+    casadi__DaeBuilder__add_s__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        std::pair< casadi::MX, casadi::MX > ret = obj->add_s(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::pair< casadi::MX*, casadi::MX* >*, std::pair< casadi::MX, casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_u" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_u"
+// cWrapperName: "casadi__DaeBuilder__add_u__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_u__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        casadi::MX ret = obj->add_u();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_u__0(std::string ** err_msg, casadi::DaeBuilder* obj);
+casadi::MX*
+    casadi__DaeBuilder__add_u__0(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        casadi::MX ret = obj->add_u();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_u" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_u"
+// cWrapperName: "casadi__DaeBuilder__add_u__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_u__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->add_u(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_u__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_u__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->add_u(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_u" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_u"
+// cWrapperName: "casadi__DaeBuilder__add_u__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_u__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        casadi::MX ret = obj->add_u(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_u__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+casadi::MX*
+    casadi__DaeBuilder__add_u__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = obj->add_u(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_variable" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_variable"
+// cWrapperName: "casadi__DaeBuilder__add_variable__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1)"
+// call: "        casadi::MX ret = obj->add_variable(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1);
+casadi::MX*
+    casadi__DaeBuilder__add_variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Sparsity* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+
+        casadi::MX ret = obj->add_variable(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_variable" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_variable"
+// cWrapperName: "casadi__DaeBuilder__add_variable__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->add_variable(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->add_variable(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_variable" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_variable"
+// cWrapperName: "casadi__DaeBuilder__add_variable__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_variable__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        casadi::MX ret = obj->add_variable(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_variable__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+casadi::MX*
+    casadi__DaeBuilder__add_variable__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = obj->add_variable(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_variable" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_variable"
+// cWrapperName: "casadi__DaeBuilder__add_variable__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__add_variable__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1)"
+// call: "        obj->add_variable(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Variable"))),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__add_variable__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1);
+void
+    casadi__DaeBuilder__add_variable__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, casadi::Variable* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Variable& x1_ = Marshaling<casadi::Variable&,casadi::Variable*>::marshal(x1);
+
+        obj->add_variable(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "add_x" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_x"
+// cWrapperName: "casadi__DaeBuilder__add_x__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_x__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        casadi::MX ret = obj->add_x();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_x__0(std::string ** err_msg, casadi::DaeBuilder* obj);
+casadi::MX*
+    casadi__DaeBuilder__add_x__0(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        casadi::MX ret = obj->add_x();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_x" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_x"
+// cWrapperName: "casadi__DaeBuilder__add_x__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_x__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->add_x(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_x__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_x__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->add_x(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_x" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_x"
+// cWrapperName: "casadi__DaeBuilder__add_x__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_x__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        casadi::MX ret = obj->add_x(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_x__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+casadi::MX*
+    casadi__DaeBuilder__add_x__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = obj->add_x(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_y" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_y"
+// cWrapperName: "casadi__DaeBuilder__add_y__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_y__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        casadi::MX ret = obj->add_y(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_y__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_y__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        casadi::MX ret = obj->add_y(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_y" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_y"
+// cWrapperName: "casadi__DaeBuilder__add_y__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_y__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1)"
+// call: "        casadi::MX ret = obj->add_y(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_y__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1);
+casadi::MX*
+    casadi__DaeBuilder__add_y__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::string* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::MX ret = obj->add_y(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_z" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_z"
+// cWrapperName: "casadi__DaeBuilder__add_z__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_z__0(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        casadi::MX ret = obj->add_z();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_z__0(std::string ** err_msg, casadi::DaeBuilder* obj);
+casadi::MX*
+    casadi__DaeBuilder__add_z__0(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        casadi::MX ret = obj->add_z();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_z" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_z"
+// cWrapperName: "casadi__DaeBuilder__add_z__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_z__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->add_z(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_z__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__add_z__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->add_z(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_z" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::add_z"
+// cWrapperName: "casadi__DaeBuilder__add_z__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__add_z__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        casadi::MX ret = obj->add_z(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__add_z__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+casadi::MX*
+    casadi__DaeBuilder__add_z__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = obj->add_z(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "create" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::create"
+// cWrapperName: "casadi__DaeBuilder__create"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__DaeBuilder__create(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2)"
+// call: "        casadi::Function ret = obj->create(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__DaeBuilder__create(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2);
+casadi::Function*
+    casadi__DaeBuilder__create(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::vector< std::string* >* x1, std::vector< std::string* >* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);
+        std::vector< std::string > x2_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x2);
+
+        casadi::Function ret = obj->create(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "der" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::der"
+// cWrapperName: "casadi__DaeBuilder__der__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__der__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        casadi::MX ret = obj->der(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__der__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+casadi::MX*
+    casadi__DaeBuilder__der__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        casadi::MX ret = obj->der(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "der" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::der"
+// cWrapperName: "casadi__DaeBuilder__der__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__der__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->der(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__der__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__der__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->der(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::derivative_start"
+// cWrapperName: "casadi__DaeBuilder__derivative_start__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__derivative_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        std::vector< double > ret = obj->derivative_start(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__derivative_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+std::vector< double >*
+    casadi__DaeBuilder__derivative_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::vector< double > ret = obj->derivative_start(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::derivative_start"
+// cWrapperName: "casadi__DaeBuilder__derivative_start__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__derivative_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// call: "        std::vector< double > ret = obj->derivative_start(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__derivative_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
+std::vector< double >*
+    casadi__DaeBuilder__derivative_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        std::vector< double > ret = obj->derivative_start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::derivative_start"
+// cWrapperName: "casadi__DaeBuilder__derivative_start__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__derivative_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        double ret = obj->derivative_start(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__derivative_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+double
+    casadi__DaeBuilder__derivative_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        double ret = obj->derivative_start(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::derivative_start"
+// cWrapperName: "casadi__DaeBuilder__derivative_start__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__derivative_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        double ret = obj->derivative_start(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__derivative_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+double
+    casadi__DaeBuilder__derivative_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        double ret = obj->derivative_start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "eliminate_alg" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::eliminate_alg"
+// cWrapperName: "casadi__DaeBuilder__eliminate_alg"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__eliminate_alg(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->eliminate_alg();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__eliminate_alg(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__eliminate_alg(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->eliminate_alg();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "eliminate_d" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::eliminate_d"
+// cWrapperName: "casadi__DaeBuilder__eliminate_d"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__eliminate_d(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->eliminate_d();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__eliminate_d(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__eliminate_d(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->eliminate_d();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "eliminate_quad" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::eliminate_quad"
+// cWrapperName: "casadi__DaeBuilder__eliminate_quad"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__eliminate_quad(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->eliminate_quad();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__eliminate_quad(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__eliminate_quad(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->eliminate_quad();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::guess"
+// cWrapperName: "casadi__DaeBuilder__guess__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__guess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        std::vector< double > ret = obj->guess(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__guess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+std::vector< double >*
+    casadi__DaeBuilder__guess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::vector< double > ret = obj->guess(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::guess"
+// cWrapperName: "casadi__DaeBuilder__guess__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__guess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// call: "        std::vector< double > ret = obj->guess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__guess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
+std::vector< double >*
+    casadi__DaeBuilder__guess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        std::vector< double > ret = obj->guess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::guess"
+// cWrapperName: "casadi__DaeBuilder__guess__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__guess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        double ret = obj->guess(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__guess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+double
+    casadi__DaeBuilder__guess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        double ret = obj->guess(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::guess"
+// cWrapperName: "casadi__DaeBuilder__guess__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__guess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        double ret = obj->guess(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__guess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+double
+    casadi__DaeBuilder__guess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        double ret = obj->guess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "make_explicit" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::make_explicit"
+// cWrapperName: "casadi__DaeBuilder__make_explicit"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__make_explicit(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->make_explicit();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__make_explicit(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__make_explicit(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->make_explicit();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "make_semi_explicit" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::make_semi_explicit"
+// cWrapperName: "casadi__DaeBuilder__make_semi_explicit"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__make_semi_explicit(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->make_semi_explicit();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__make_semi_explicit(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__make_semi_explicit(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->make_semi_explicit();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::max"
+// cWrapperName: "casadi__DaeBuilder__max__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        std::vector< double > ret = obj->max(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+std::vector< double >*
+    casadi__DaeBuilder__max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::vector< double > ret = obj->max(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::max"
+// cWrapperName: "casadi__DaeBuilder__max__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// call: "        std::vector< double > ret = obj->max(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
+std::vector< double >*
+    casadi__DaeBuilder__max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        std::vector< double > ret = obj->max(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::max"
+// cWrapperName: "casadi__DaeBuilder__max__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        double ret = obj->max(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+double
+    casadi__DaeBuilder__max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        double ret = obj->max(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::max"
+// cWrapperName: "casadi__DaeBuilder__max__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        double ret = obj->max(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+double
+    casadi__DaeBuilder__max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        double ret = obj->max(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::min"
+// cWrapperName: "casadi__DaeBuilder__min__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        std::vector< double > ret = obj->min(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+std::vector< double >*
+    casadi__DaeBuilder__min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::vector< double > ret = obj->min(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::min"
+// cWrapperName: "casadi__DaeBuilder__min__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// call: "        std::vector< double > ret = obj->min(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
+std::vector< double >*
+    casadi__DaeBuilder__min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        std::vector< double > ret = obj->min(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::min"
+// cWrapperName: "casadi__DaeBuilder__min__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        double ret = obj->min(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+double
+    casadi__DaeBuilder__min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        double ret = obj->min(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::min"
+// cWrapperName: "casadi__DaeBuilder__min__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        double ret = obj->min(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+double
+    casadi__DaeBuilder__min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        double ret = obj->min(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nominal" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::nominal"
+// cWrapperName: "casadi__DaeBuilder__nominal__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        std::vector< double > ret = obj->nominal(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+std::vector< double >*
+    casadi__DaeBuilder__nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::vector< double > ret = obj->nominal(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nominal" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::nominal"
+// cWrapperName: "casadi__DaeBuilder__nominal__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        double ret = obj->nominal(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+double
+    casadi__DaeBuilder__nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        double ret = obj->nominal(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator ()" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::operator ()"
+// cWrapperName: "casadi__DaeBuilder__operator__call"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__DaeBuilder__operator__call(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->operator ()(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__DaeBuilder__operator__call(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::MX*
+    casadi__DaeBuilder__operator__call(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->operator ()(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "parse_fmi" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::parse_fmi"
+// cWrapperName: "casadi__DaeBuilder__parse_fmi"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__parse_fmi(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        obj->parse_fmi(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__parse_fmi(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+void
+    casadi__DaeBuilder__parse_fmi(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->parse_fmi(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::sanity_check"
+// cWrapperName: "casadi__DaeBuilder__sanity_check"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__sanity_check(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->sanity_check();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__sanity_check(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__sanity_check(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->sanity_check();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "scale_equations" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::scale_equations"
+// cWrapperName: "casadi__DaeBuilder__scale_equations"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__scale_equations(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->scale_equations();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__scale_equations(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__scale_equations(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->scale_equations();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "scale_variables" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::scale_variables"
+// cWrapperName: "casadi__DaeBuilder__scale_variables"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__scale_variables(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->scale_variables();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__scale_variables(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__scale_variables(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->scale_variables();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_derivative_start"
+// cWrapperName: "casadi__DaeBuilder__set_derivative_start__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_derivative_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// call: "        obj->set_derivative_start(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_derivative_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
+void
+    casadi__DaeBuilder__set_derivative_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+
+        obj->set_derivative_start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_derivative_start"
+// cWrapperName: "casadi__DaeBuilder__set_derivative_start__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_derivative_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// call: "        obj->set_derivative_start(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_derivative_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
+void
+    casadi__DaeBuilder__set_derivative_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_derivative_start(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_derivative_start"
+// cWrapperName: "casadi__DaeBuilder__set_derivative_start__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_derivative_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// call: "        obj->set_derivative_start(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_derivative_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
+void
+    casadi__DaeBuilder__set_derivative_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+
+        obj->set_derivative_start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_derivative_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_derivative_start"
+// cWrapperName: "casadi__DaeBuilder__set_derivative_start__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_derivative_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// call: "        obj->set_derivative_start(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_derivative_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
+void
+    casadi__DaeBuilder__set_derivative_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_derivative_start(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_guess"
+// cWrapperName: "casadi__DaeBuilder__set_guess__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_guess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// call: "        obj->set_guess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_guess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
+void
+    casadi__DaeBuilder__set_guess__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+
+        obj->set_guess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_guess"
+// cWrapperName: "casadi__DaeBuilder__set_guess__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_guess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// call: "        obj->set_guess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_guess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
+void
+    casadi__DaeBuilder__set_guess__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_guess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_guess"
+// cWrapperName: "casadi__DaeBuilder__set_guess__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_guess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// call: "        obj->set_guess(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_guess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
+void
+    casadi__DaeBuilder__set_guess__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+
+        obj->set_guess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_guess" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_guess"
+// cWrapperName: "casadi__DaeBuilder__set_guess__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_guess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// call: "        obj->set_guess(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_guess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
+void
+    casadi__DaeBuilder__set_guess__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_guess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_max"
+// cWrapperName: "casadi__DaeBuilder__set_max__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// call: "        obj->set_max(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
+void
+    casadi__DaeBuilder__set_max__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+
+        obj->set_max(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_max"
+// cWrapperName: "casadi__DaeBuilder__set_max__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// call: "        obj->set_max(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
+void
+    casadi__DaeBuilder__set_max__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_max(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_max"
+// cWrapperName: "casadi__DaeBuilder__set_max__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// call: "        obj->set_max(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
+void
+    casadi__DaeBuilder__set_max__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+
+        obj->set_max(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_max" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_max"
+// cWrapperName: "casadi__DaeBuilder__set_max__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// call: "        obj->set_max(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
+void
+    casadi__DaeBuilder__set_max__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_max(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_min"
+// cWrapperName: "casadi__DaeBuilder__set_min__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// call: "        obj->set_min(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
+void
+    casadi__DaeBuilder__set_min__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+
+        obj->set_min(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_min"
+// cWrapperName: "casadi__DaeBuilder__set_min__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// call: "        obj->set_min(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
+void
+    casadi__DaeBuilder__set_min__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_min(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_min"
+// cWrapperName: "casadi__DaeBuilder__set_min__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// call: "        obj->set_min(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
+void
+    casadi__DaeBuilder__set_min__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+
+        obj->set_min(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_min" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_min"
+// cWrapperName: "casadi__DaeBuilder__set_min__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// call: "        obj->set_min(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
+void
+    casadi__DaeBuilder__set_min__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_min(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nominal" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_nominal"
+// cWrapperName: "casadi__DaeBuilder__set_nominal__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// call: "        obj->set_nominal(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
+void
+    casadi__DaeBuilder__set_nominal__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+
+        obj->set_nominal(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nominal" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_nominal"
+// cWrapperName: "casadi__DaeBuilder__set_nominal__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// call: "        obj->set_nominal(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
+void
+    casadi__DaeBuilder__set_nominal__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+
+        obj->set_nominal(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_start"
+// cWrapperName: "casadi__DaeBuilder__set_start__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1)"
+// call: "        obj->set_start(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1);
+void
+    casadi__DaeBuilder__set_start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+
+        obj->set_start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_start"
+// cWrapperName: "casadi__DaeBuilder__set_start__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2)"
+// call: "        obj->set_start(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (StdVec CDouble)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2);
+void
+    casadi__DaeBuilder__set_start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, std::vector< double >* x1, int x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_start(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_start"
+// cWrapperName: "casadi__DaeBuilder__set_start__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1)"
+// call: "        obj->set_start(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1);
+void
+    casadi__DaeBuilder__set_start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+
+        obj->set_start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_start"
+// cWrapperName: "casadi__DaeBuilder__set_start__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2)"
+// call: "        obj->set_start(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CDouble,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2);
+void
+    casadi__DaeBuilder__set_start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, double x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        double x1_ = Marshaling<double,double>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->set_start(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_unit" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::set_unit"
+// cWrapperName: "casadi__DaeBuilder__set_unit"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__set_unit(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1)"
+// call: "        obj->set_unit(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__DaeBuilder__set_unit(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1);
+void
+    casadi__DaeBuilder__set_unit(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        obj->set_unit(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sort_alg" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::sort_alg"
+// cWrapperName: "casadi__DaeBuilder__sort_alg"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__sort_alg(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->sort_alg();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__sort_alg(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__sort_alg(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->sort_alg();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sort_d" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::sort_d"
+// cWrapperName: "casadi__DaeBuilder__sort_d"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__sort_d(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->sort_d();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__sort_d(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__sort_d(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->sort_d();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sort_dae" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::sort_dae"
+// cWrapperName: "casadi__DaeBuilder__sort_dae"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__sort_dae(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->sort_dae();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__sort_dae(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__sort_dae(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->sort_dae();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "split_d" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::split_d"
+// cWrapperName: "casadi__DaeBuilder__split_d"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__split_d(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->split_d();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__split_d(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__split_d(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->split_d();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "split_dae" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::split_dae"
+// cWrapperName: "casadi__DaeBuilder__split_dae"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__DaeBuilder__split_dae(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        obj->split_dae();"
+// params: []
+extern "C"
+void
+    casadi__DaeBuilder__split_dae(std::string ** err_msg, casadi::DaeBuilder* obj);
+void
+    casadi__DaeBuilder__split_dae(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        obj->split_dae();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::start"
+// cWrapperName: "casadi__DaeBuilder__start__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        std::vector< double > ret = obj->start(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+std::vector< double >*
+    casadi__DaeBuilder__start__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::vector< double > ret = obj->start(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::start"
+// cWrapperName: "casadi__DaeBuilder__start__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__DaeBuilder__start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1)"
+// call: "        std::vector< double > ret = obj->start(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< double >*
+    casadi__DaeBuilder__start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1);
+std::vector< double >*
+    casadi__DaeBuilder__start__1(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0, int x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        std::vector< double > ret = obj->start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::start"
+// cWrapperName: "casadi__DaeBuilder__start__2"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        double ret = obj->start(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+double
+    casadi__DaeBuilder__start__2(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        double ret = obj->start(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "start" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::start"
+// cWrapperName: "casadi__DaeBuilder__start__3"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__DaeBuilder__start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1)"
+// call: "        double ret = obj->start(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+double
+    casadi__DaeBuilder__start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1);
+double
+    casadi__DaeBuilder__start__3(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        double ret = obj->start(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "unit" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::unit"
+// cWrapperName: "casadi__DaeBuilder__unit__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DaeBuilder__unit__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0)"
+// call: "        std::string ret = obj->unit(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::string*
+    casadi__DaeBuilder__unit__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0);
+std::string*
+    casadi__DaeBuilder__unit__0(std::string ** err_msg, casadi::DaeBuilder* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::string ret = obj->unit(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "unit" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::unit"
+// cWrapperName: "casadi__DaeBuilder__unit__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DaeBuilder__unit__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        std::string ret = obj->unit(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::string*
+    casadi__DaeBuilder__unit__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+std::string*
+    casadi__DaeBuilder__unit__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::string ret = obj->unit(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "variable" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::variable"
+// cWrapperName: "casadi__DaeBuilder__variable__0"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Variable"))
+// cWrapperRetType: "casadi::Variable*"
+// proto: "casadi::Variable*\n    casadi__DaeBuilder__variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::Variable ret = obj->variable(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Variable*
+    casadi__DaeBuilder__variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::Variable*
+    casadi__DaeBuilder__variable__0(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Variable ret = obj->variable(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Variable*, casadi::Variable >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "variable" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::variable"
+// cWrapperName: "casadi__DaeBuilder__variable__1"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
+// cWrapperRetType: "casadi::Variable*"
+// proto: "casadi::Variable*\n    casadi__DaeBuilder__variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0)"
+// call: "        casadi::Variable ret = obj->variable(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Variable*
+    casadi__DaeBuilder__variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0);
+casadi::Variable*
+    casadi__DaeBuilder__variable__1(std::string ** err_msg, casadi::DaeBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Variable ret = obj->variable(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Variable*, casadi::Variable >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::getRepresentation"
+// cWrapperName: "casadi__DaeBuilder__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DaeBuilder__getRepresentation(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__DaeBuilder__getRepresentation(std::string ** err_msg, casadi::DaeBuilder* obj);
+std::string*
+    casadi__DaeBuilder__getRepresentation(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::DaeBuilder"
+// cppName: "casadi::DaeBuilder::getDescription"
+// cWrapperName: "casadi__DaeBuilder__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__DaeBuilder__getDescription(std::string ** err_msg, casadi::DaeBuilder* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__DaeBuilder__getDescription(std::string ** err_msg, casadi::DaeBuilder* obj);
+std::string*
+    casadi__DaeBuilder__getDescription(std::string ** err_msg, casadi::DaeBuilder* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "Function")===============
+// classType: UserType (Namespace ["casadi"]) (Name "Function")
+extern "C"
+void delete_casadi__Function(casadi::Function* obj);
+void delete_casadi__Function(casadi::Function* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::MX > x1_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x1);
+        std::vector< std::string > x2_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::MX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::MX > x1_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x1);
+        std::vector< std::string > x2_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+        std::vector< std::string > x4_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x4);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+        std::vector< std::string > x4_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x4);
+        std::map< std::string, casadi::GenericType > x5_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x5);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__4"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__5"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
+        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__6"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::SX > x1_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x1);
+        std::vector< std::string > x2_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__7"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::map< std::string, casadi::SX* >* x1, std::vector< std::string* >* x2, std::vector< std::string* >* x3, std::map< std::string, casadi::GenericType* >* x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::SX > x1_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x1);
+        std::vector< std::string > x2_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__8"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+        std::vector< std::string > x4_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x4);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__9"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdVec StdString)),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::vector< std::string* >* x3, std::vector< std::string* >* x4, std::map< std::string, casadi::GenericType* >* x5){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
+        std::vector< std::string > x3_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x3);
+        std::vector< std::string > x4_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x4);
+        std::map< std::string, casadi::GenericType > x5_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x5);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__10"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__10(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__10(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__10(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__11"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__11(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__11(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__11(std::string ** err_msg, std::string* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, std::map< std::string, casadi::GenericType* >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
+        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__12"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__12(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__12(std::string ** err_msg, std::string* x0);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__12(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function"
+// cWrapperName: "casadi__Function__CONSTRUCTOR__13"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__CONSTRUCTOR__13(std::string ** err_msg)"
+// call: "        casadi::Function* ret = (casadi::Function*)new casadi::Function();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__13(std::string ** err_msg);
+casadi::Function*
+    casadi__Function__CONSTRUCTOR__13(std::string ** err_msg){
+    try {
+
+        casadi::Function* ret = (casadi::Function*)new casadi::Function();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "addMonitor" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::addMonitor"
+// cWrapperName: "casadi__Function__addMonitor"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        obj->addMonitor(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+void
+    casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->addMonitor(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1)"
+// call: "        obj->call(x0_, x1_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1);
+void
+    casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1){
+    try {
+        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
+        std::map< std::string, casadi::MX > x1_ = std::map< std::string, casadi::MX >();  // Swig output
+
+        obj->call(x0_, x1_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2)"
+// call: "        obj->call(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2);
+void
+    casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2){
+    try {
+        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
+        std::map< std::string, casadi::MX > x1_ = std::map< std::string, casadi::MX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->call(x0_, x1_, x2_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2, int x3)"
+// call: "        obj->call(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2, int x3);
+void
+    casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::map< std::string, casadi::MX* >** x1, int x2, int x3){
+    try {
+        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
+        std::map< std::string, casadi::MX > x1_ = std::map< std::string, casadi::MX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->call(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1)"
+// call: "        obj->call(x0_, x1_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1);
+void
+    casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1){
+    try {
+        std::map< std::string, casadi::SX > x0_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x0);
+        std::map< std::string, casadi::SX > x1_ = std::map< std::string, casadi::SX >();  // Swig output
+
+        obj->call(x0_, x1_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::SX* >*, std::map< std::string, casadi::SX > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2)"
+// call: "        obj->call(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2);
+void
+    casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2){
+    try {
+        std::map< std::string, casadi::SX > x0_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x0);
+        std::map< std::string, casadi::SX > x1_ = std::map< std::string, casadi::SX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->call(x0_, x1_, x2_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::SX* >*, std::map< std::string, casadi::SX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2, int x3)"
+// call: "        obj->call(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2, int x3);
+void
+    casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::SX* >* x0, std::map< std::string, casadi::SX* >** x1, int x2, int x3){
+    try {
+        std::map< std::string, casadi::SX > x0_ = Marshaling<std::map< std::string, casadi::SX >,std::map< std::string, casadi::SX* >*>::marshal(x0);
+        std::map< std::string, casadi::SX > x1_ = std::map< std::string, casadi::SX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->call(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::SX* >*, std::map< std::string, casadi::SX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1)"
+// call: "        obj->call(x0_, x1_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1);
+void
+    casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1){
+    try {
+        std::map< std::string, casadi::DM > x0_ = Marshaling<std::map< std::string, casadi::DM >,std::map< std::string, casadi::DM* >*>::marshal(x0);
+        std::map< std::string, casadi::DM > x1_ = std::map< std::string, casadi::DM >();  // Swig output
+
+        obj->call(x0_, x1_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::DM* >*, std::map< std::string, casadi::DM > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2)"
+// call: "        obj->call(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2);
+void
+    casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2){
+    try {
+        std::map< std::string, casadi::DM > x0_ = Marshaling<std::map< std::string, casadi::DM >,std::map< std::string, casadi::DM* >*>::marshal(x0);
+        std::map< std::string, casadi::DM > x1_ = std::map< std::string, casadi::DM >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->call(x0_, x1_, x2_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::DM* >*, std::map< std::string, casadi::DM > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2, int x3)"
+// call: "        obj->call(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdMap StdString (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2, int x3);
+void
+    casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::DM* >* x0, std::map< std::string, casadi::DM* >** x1, int x2, int x3){
+    try {
+        std::map< std::string, casadi::DM > x0_ = Marshaling<std::map< std::string, casadi::DM >,std::map< std::string, casadi::DM* >*>::marshal(x0);
+        std::map< std::string, casadi::DM > x1_ = std::map< std::string, casadi::DM >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->call(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::map< std::string, casadi::DM* >*, std::map< std::string, casadi::DM > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1)"
+// call: "        obj->call(x0_, x1_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__call__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1);
+void
+    casadi__Function__call__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = std::vector< casadi::MX >();  // Swig output
+
+        obj->call(x0_, x1_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__10"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__10(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2)"
+// call: "        obj->call(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__10(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2);
+void
+    casadi__Function__call__10(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = std::vector< casadi::MX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->call(x0_, x1_, x2_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__11"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__11(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2, int x3)"
+// call: "        obj->call(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__11(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2, int x3);
+void
+    casadi__Function__call__11(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, int x2, int x3){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = std::vector< casadi::MX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->call(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__12"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__12(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1)"
+// call: "        obj->call(x0_, x1_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__call__12(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1);
+void
+    casadi__Function__call__12(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = std::vector< casadi::SX >();  // Swig output
+
+        obj->call(x0_, x1_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__13"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__13(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2)"
+// call: "        obj->call(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__13(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2);
+void
+    casadi__Function__call__13(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = std::vector< casadi::SX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->call(x0_, x1_, x2_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__14"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__14(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2, int x3)"
+// call: "        obj->call(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__14(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2, int x3);
+void
+    casadi__Function__call__14(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, int x2, int x3){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = std::vector< casadi::SX >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->call(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__15"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__15(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1)"
+// call: "        obj->call(x0_, x1_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__call__15(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1);
+void
+    casadi__Function__call__15(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = std::vector< casadi::DM >();  // Swig output
+
+        obj->call(x0_, x1_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__16"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__16(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2)"
+// call: "        obj->call(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__16(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2);
+void
+    casadi__Function__call__16(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = std::vector< casadi::DM >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->call(x0_, x1_, x2_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "call" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::call"
+// cWrapperName: "casadi__Function__call__17"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__call__17(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2, int x3)"
+// call: "        obj->call(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__call__17(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2, int x3);
+void
+    casadi__Function__call__17(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, int x2, int x3){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = std::vector< casadi::DM >();  // Swig output
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->call(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "checkInputs" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::checkInputs"
+// cWrapperName: "casadi__Function__checkInputs"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj)"
+// call: "        obj->checkInputs();"
+// params: []
+extern "C"
+void
+    casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj);
+void
+    casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        obj->checkInputs();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "check_name" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::check_name"
+// cWrapperName: "casadi__Function__check_name"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__check_name(std::string ** err_msg, std::string* x0)"
+// call: "        bool ret = casadi::Function::check_name(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__check_name(std::string ** err_msg, std::string* x0);
+int
+    casadi__Function__check_name(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        bool ret = casadi::Function::check_name(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "checkout" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::checkout"
+// cWrapperName: "casadi__Function__checkout"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__checkout(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->checkout();"
+// params: []
+extern "C"
+int
+    casadi__Function__checkout(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__checkout(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->checkout();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "conditional" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::conditional"
+// cWrapperName: "casadi__Function__conditional__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__conditional__0(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2)"
+// call: "        casadi::Function ret = casadi::Function::conditional(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Function")))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__conditional__0(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2);
+casadi::Function*
+    casadi__Function__conditional__0(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::Function > x1_ = Marshaling<std::vector< casadi::Function >,std::vector< casadi::Function* >*>::marshal(x1);
+        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
+
+        casadi::Function ret = casadi::Function::conditional(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "conditional" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::conditional"
+// cWrapperName: "casadi__Function__conditional__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__conditional__1(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// call: "        casadi::Function ret = casadi::Function::conditional(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Function")))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__conditional__1(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3);
+casadi::Function*
+    casadi__Function__conditional__1(std::string ** err_msg, std::string* x0, std::vector< casadi::Function* >* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::vector< casadi::Function > x1_ = Marshaling<std::vector< casadi::Function >,std::vector< casadi::Function* >*>::marshal(x1);
+        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
+        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
+
+        casadi::Function ret = casadi::Function::conditional(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "default_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::default_in"
+// cWrapperName: "casadi__Function__default_in"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__Function__default_in(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        double ret = obj->default_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+double
+    casadi__Function__default_in(std::string ** err_msg, casadi::Function* obj, int x0);
+double
+    casadi__Function__default_in(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        double ret = obj->default_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__derivative__0(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::Function ret = obj->derivative(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__derivative__0(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::Function*
+    casadi__Function__derivative__0(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->derivative(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__derivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5);
+void
+    casadi__Function__derivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = std::vector< casadi::MX >();  // Swig output
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::MX > > x5_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x5_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__derivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6);
+void
+    casadi__Function__derivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = std::vector< casadi::MX >();  // Swig output
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::MX > > x5_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        bool x6_ = Marshaling<bool,int>::marshal(x6);
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x5_ );
+        // x6 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6, int x7)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6, int x7)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__derivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6, int x7);
+void
+    casadi__Function__derivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >** x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >** x5, int x6, int x7){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = std::vector< casadi::MX >();  // Swig output
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::MX > > x5_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        bool x6_ = Marshaling<bool,int>::marshal(x6);
+        bool x7_ = Marshaling<bool,int>::marshal(x7);
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x5_ );
+        // x6 is not a swig output
+        // x7 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__derivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5);
+void
+    casadi__Function__derivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = std::vector< casadi::SX >();  // Swig output
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::SX > > x5_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x5_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__derivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6);
+void
+    casadi__Function__derivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = std::vector< casadi::SX >();  // Swig output
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::SX > > x5_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        bool x6_ = Marshaling<bool,int>::marshal(x6);
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x5_ );
+        // x6 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6, int x7)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6, int x7)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__derivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6, int x7);
+void
+    casadi__Function__derivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >** x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >** x5, int x6, int x7){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = std::vector< casadi::SX >();  // Swig output
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::SX > > x5_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        bool x6_ = Marshaling<bool,int>::marshal(x6);
+        bool x7_ = Marshaling<bool,int>::marshal(x7);
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x5_ );
+        // x6 is not a swig output
+        // x7 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__derivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5);
+void
+    casadi__Function__derivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = std::vector< casadi::DM >();  // Swig output
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        std::vector< std::vector< casadi::DM > > x4_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::DM > > x5_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x5_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__derivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6);
+void
+    casadi__Function__derivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = std::vector< casadi::DM >();  // Swig output
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        std::vector< std::vector< casadi::DM > > x4_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::DM > > x5_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        bool x6_ = Marshaling<bool,int>::marshal(x6);
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x5_ );
+        // x6 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "derivative" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::derivative"
+// cWrapperName: "casadi__Function__derivative__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6, int x7)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__derivative__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6, int x7)"
+// call: "        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__derivative__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6, int x7);
+void
+    casadi__Function__derivative__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >** x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, std::vector< std::vector< casadi::DM* >* >* x4, std::vector< std::vector< casadi::DM* >* >** x5, int x6, int x7){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = std::vector< casadi::DM >();  // Swig output
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        std::vector< std::vector< casadi::DM > > x4_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x4);
+        std::vector< std::vector< casadi::DM > > x5_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        bool x6_ = Marshaling<bool,int>::marshal(x6);
+        bool x7_ = Marshaling<bool,int>::marshal(x7);
+
+        obj->derivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
+        // x0 is not a swig output
+        *x1 = WrapReturn< std::vector< casadi::DM* >*, std::vector< casadi::DM > >::wrapReturn( x1_ );
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        *x5 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x5_ );
+        // x6 is not a swig output
+        // x7 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "expand" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::expand"
+// cWrapperName: "casadi__Function__expand__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__expand__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Function ret = obj->expand(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__expand__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Function*
+    casadi__Function__expand__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Function ret = obj->expand(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "expand" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::expand"
+// cWrapperName: "casadi__Function__expand__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__expand__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// call: "        casadi::Function ret = obj->expand(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__expand__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
+casadi::Function*
+    casadi__Function__expand__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
+
+        casadi::Function ret = obj->expand(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "expand" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::expand"
+// cWrapperName: "casadi__Function__expand__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__expand__2(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->expand();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__expand__2(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__expand__2(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->expand();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "fix_name" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::fix_name"
+// cWrapperName: "casadi__Function__fix_name"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Function__fix_name(std::string ** err_msg, std::string* x0)"
+// call: "        std::string ret = casadi::Function::fix_name(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::string*
+    casadi__Function__fix_name(std::string ** err_msg, std::string* x0);
+std::string*
+    casadi__Function__fix_name(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::string ret = casadi::Function::fix_name(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__forward__0(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Function ret = obj->forward(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__forward__0(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Function*
+    casadi__Function__forward__0(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Function ret = obj->forward(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__forward__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3);
+void
+    casadi__Function__forward__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x1);
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+
+        obj->forward(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__forward__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4);
+void
+    casadi__Function__forward__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x1);
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->forward(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__forward__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5);
+void
+    casadi__Function__forward__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x1);
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+        bool x5_ = Marshaling<bool,int>::marshal(x5);
+
+        obj->forward(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__forward__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3);
+void
+    casadi__Function__forward__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+
+        obj->forward(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__forward__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4);
+void
+    casadi__Function__forward__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->forward(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__forward__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5);
+void
+    casadi__Function__forward__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+        bool x5_ = Marshaling<bool,int>::marshal(x5);
+
+        obj->forward(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__forward__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3);
+void
+    casadi__Function__forward__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+
+        obj->forward(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__forward__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4);
+void
+    casadi__Function__forward__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->forward(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::forward"
+// cWrapperName: "casadi__Function__forward__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__forward__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5)"
+// call: "        obj->forward(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__forward__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5);
+void
+    casadi__Function__forward__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+        bool x5_ = Marshaling<bool,int>::marshal(x5);
+
+        obj->forward(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "free_mx" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::free_mx"
+// cWrapperName: "casadi__Function__free_mx"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__Function__free_mx(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::vector< casadi::MX > ret = obj->free_mx();"
+// params: []
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__Function__free_mx(std::string ** err_msg, casadi::Function* obj);
+std::vector< casadi::MX* >*
+    casadi__Function__free_mx(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::vector< casadi::MX > ret = obj->free_mx();
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "free_sx" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::free_sx"
+// cWrapperName: "casadi__Function__free_sx"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__Function__free_sx(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::SX ret = obj->free_sx();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__Function__free_sx(std::string ** err_msg, casadi::Function* obj);
+casadi::SX*
+    casadi__Function__free_sx(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::SX ret = obj->free_sx();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "fullJacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::fullJacobian"
+// cWrapperName: "casadi__Function__fullJacobian"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->fullJacobian();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->fullJacobian();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "generate" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::generate"
+// cWrapperName: "casadi__Function__generate__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__generate__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        obj->generate();"
+// params: []
+extern "C"
+void
+    casadi__Function__generate__0(std::string ** err_msg, casadi::Function* obj);
+void
+    casadi__Function__generate__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        obj->generate();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "generate" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::generate"
+// cWrapperName: "casadi__Function__generate__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__generate__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0)"
+// call: "        obj->generate(x0_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__generate__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0);
+void
+    casadi__Function__generate__1(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::GenericType* >* x0){
+    try {
+        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
+
+        obj->generate(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "generate" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::generate"
+// cWrapperName: "casadi__Function__generate__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__generate__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        obj->generate(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__generate__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+void
+    casadi__Function__generate__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->generate(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "generate" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::generate"
+// cWrapperName: "casadi__Function__generate__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__generate__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// call: "        obj->generate(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__generate__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
+void
+    casadi__Function__generate__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
+
+        obj->generate(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "generate_dependencies" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::generate_dependencies"
+// cWrapperName: "casadi__Function__generate_dependencies__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__generate_dependencies__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        obj->generate_dependencies(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__generate_dependencies__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+void
+    casadi__Function__generate_dependencies__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->generate_dependencies(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "generate_dependencies" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::generate_dependencies"
+// cWrapperName: "casadi__Function__generate_dependencies__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__generate_dependencies__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// call: "        obj->generate_dependencies(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__generate_dependencies__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
+void
+    casadi__Function__generate_dependencies__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
+
+        obj->generate_dependencies(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "generate_lifted" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::generate_lifted"
+// cWrapperName: "casadi__Function__generate_lifted"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function** x0, casadi::Function** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__generate_lifted(std::string ** err_msg, casadi::Function* obj, casadi::Function** x0, casadi::Function** x1)"
+// call: "        obj->generate_lifted(x0_, x1_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "Function")),SwigOutput True),(Ref (UserType (Namespace ["casadi"]) (Name "Function")),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__generate_lifted(std::string ** err_msg, casadi::Function* obj, casadi::Function** x0, casadi::Function** x1);
+void
+    casadi__Function__generate_lifted(std::string ** err_msg, casadi::Function* obj, casadi::Function** x0, casadi::Function** x1){
+    try {
+        casadi::Function x0_ = casadi::Function();  // Swig output
+        casadi::Function x1_ = casadi::Function();  // Swig output
+
+        obj->generate_lifted(x0_, x1_);
+        *x0 = WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( x0_ );
+        *x1 = WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "getAlgorithmSize" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::getAlgorithmSize"
+// cWrapperName: "casadi__Function__getAlgorithmSize"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__getAlgorithmSize(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->getAlgorithmSize();"
+// params: []
+extern "C"
+int
+    casadi__Function__getAlgorithmSize(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__getAlgorithmSize(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->getAlgorithmSize();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getAtomicInput" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::getAtomicInput"
+// cWrapperName: "casadi__Function__getAtomicInput"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__Function__getAtomicInput(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        std::pair< int, int > ret = obj->getAtomicInput(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::pair< int, int >*
+    casadi__Function__getAtomicInput(std::string ** err_msg, casadi::Function* obj, int x0);
+std::pair< int, int >*
+    casadi__Function__getAtomicInput(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::pair< int, int > ret = obj->getAtomicInput(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getAtomicInputReal" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::getAtomicInputReal"
+// cWrapperName: "casadi__Function__getAtomicInputReal"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__Function__getAtomicInputReal(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        double ret = obj->getAtomicInputReal(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+double
+    casadi__Function__getAtomicInputReal(std::string ** err_msg, casadi::Function* obj, int x0);
+double
+    casadi__Function__getAtomicInputReal(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        double ret = obj->getAtomicInputReal(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getAtomicOperation" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::getAtomicOperation"
+// cWrapperName: "casadi__Function__getAtomicOperation"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__getAtomicOperation(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->getAtomicOperation(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__getAtomicOperation(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__getAtomicOperation(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->getAtomicOperation(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getAtomicOutput" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::getAtomicOutput"
+// cWrapperName: "casadi__Function__getAtomicOutput"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__getAtomicOutput(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->getAtomicOutput(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__getAtomicOutput(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__getAtomicOutput(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->getAtomicOutput(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getWorkSize" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::getWorkSize"
+// cWrapperName: "casadi__Function__getWorkSize"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__getWorkSize(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->getWorkSize();"
+// params: []
+extern "C"
+int
+    casadi__Function__getWorkSize(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__getWorkSize(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->getWorkSize();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "gradient" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::gradient"
+// cWrapperName: "casadi__Function__gradient__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->gradient(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
+casadi::Function*
+    casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->gradient(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "gradient" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::gradient"
+// cWrapperName: "casadi__Function__gradient__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->gradient(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
+casadi::Function*
+    casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->gradient(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "gradient" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::gradient"
+// cWrapperName: "casadi__Function__gradient__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Function ret = obj->gradient(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Function*
+    casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Function ret = obj->gradient(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "gradient" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::gradient"
+// cWrapperName: "casadi__Function__gradient__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// call: "        casadi::Function ret = obj->gradient(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
+casadi::Function*
+    casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->gradient(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "gradient" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::gradient"
+// cWrapperName: "casadi__Function__gradient__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->gradient();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->gradient();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "gradient" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::gradient"
+// cWrapperName: "casadi__Function__gradient__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Function ret = obj->gradient(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Function*
+    casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Function ret = obj->gradient(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "gradient" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::gradient"
+// cWrapperName: "casadi__Function__gradient__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::Function ret = obj->gradient(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::Function*
+    casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->gradient(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_free" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::has_free"
+// cWrapperName: "casadi__Function__has_free"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__has_free(std::string ** err_msg, casadi::Function* obj)"
+// call: "        bool ret = obj->has_free();"
+// params: []
+extern "C"
+int
+    casadi__Function__has_free(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__has_free(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        bool ret = obj->has_free();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hessian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::hessian"
+// cWrapperName: "casadi__Function__hessian__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->hessian(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
+casadi::Function*
+    casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->hessian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hessian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::hessian"
+// cWrapperName: "casadi__Function__hessian__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->hessian(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
+casadi::Function*
+    casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->hessian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hessian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::hessian"
+// cWrapperName: "casadi__Function__hessian__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Function ret = obj->hessian(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Function*
+    casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Function ret = obj->hessian(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hessian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::hessian"
+// cWrapperName: "casadi__Function__hessian__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// call: "        casadi::Function ret = obj->hessian(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
+casadi::Function*
+    casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->hessian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hessian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::hessian"
+// cWrapperName: "casadi__Function__hessian__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->hessian();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->hessian();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hessian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::hessian"
+// cWrapperName: "casadi__Function__hessian__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Function ret = obj->hessian(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Function*
+    casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Function ret = obj->hessian(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hessian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::hessian"
+// cWrapperName: "casadi__Function__hessian__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::Function ret = obj->hessian(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::Function*
+    casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->hessian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "if_else" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::if_else"
+// cWrapperName: "casadi__Function__if_else__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__if_else__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2)"
+// call: "        casadi::Function ret = casadi::Function::if_else(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__if_else__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2);
+casadi::Function*
+    casadi__Function__if_else__0(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
+        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
+
+        casadi::Function ret = casadi::Function::if_else(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "if_else" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::if_else"
+// cWrapperName: "casadi__Function__if_else__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__if_else__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3)"
+// call: "        casadi::Function ret = casadi::Function::if_else(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__if_else__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3);
+casadi::Function*
+    casadi__Function__if_else__1(std::string ** err_msg, std::string* x0, casadi::Function* x1, casadi::Function* x2, std::map< std::string, casadi::GenericType* >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Function& x1_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x1);
+        casadi::Function& x2_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x2);
+        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
+
+        casadi::Function ret = casadi::Function::if_else(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "index_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::index_in"
+// cWrapperName: "casadi__Function__index_in"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__index_in(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->index_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__index_in(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__index_in(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->index_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "index_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::index_out"
+// cWrapperName: "casadi__Function__index_out"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__index_out(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->index_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__index_out(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__index_out(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->index_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "integrator_dae" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::integrator_dae"
+// cWrapperName: "casadi__Function__integrator_dae"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__integrator_dae(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->integrator_dae();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__integrator_dae(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__integrator_dae(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->integrator_dae();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_a" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::is_a"
+// cWrapperName: "casadi__Function__is_a__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__is_a__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        bool ret = obj->is_a(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__is_a__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__is_a__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        bool ret = obj->is_a(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_a" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::is_a"
+// cWrapperName: "casadi__Function__is_a__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__is_a__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// call: "        bool ret = obj->is_a(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__is_a__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
+int
+    casadi__Function__is_a__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        bool ret = obj->is_a(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
+casadi::Function*
+    casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2);
+casadi::Function*
+    casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
+casadi::Function*
+    casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
+casadi::Function*
+    casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2);
+casadi::Function*
+    casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3);
+casadi::Function*
+    casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Function ret = obj->jacobian(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Function*
+    casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Function ret = obj->jacobian(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
+casadi::Function*
+    casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2);
+casadi::Function*
+    casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3);
+casadi::Function*
+    casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__10"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->jacobian();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->jacobian();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__11"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Function ret = obj->jacobian(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Function*
+    casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Function ret = obj->jacobian(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__12"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::Function*
+    casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__13"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2);
+casadi::Function*
+    casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "jacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::jacobian"
+// cWrapperName: "casadi__Function__jacobian__14"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
+// call: "        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3);
+casadi::Function*
+    casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Function ret = obj->jacobian(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "kernel_sum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::kernel_sum"
+// cWrapperName: "casadi__Function__kernel_sum__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__kernel_sum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3)"
+// call: "        casadi::Function ret = obj->kernel_sum(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False),(CDouble,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__kernel_sum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3);
+casadi::Function*
+    casadi__Function__kernel_sum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
+        double x2_ = Marshaling<double,double>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        casadi::Function ret = obj->kernel_sum(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "kernel_sum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::kernel_sum"
+// cWrapperName: "casadi__Function__kernel_sum__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3, std::map< std::string, casadi::GenericType* >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__kernel_sum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3, std::map< std::string, casadi::GenericType* >* x4)"
+// call: "        casadi::Function ret = obj->kernel_sum(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False),(CDouble,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__kernel_sum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3, std::map< std::string, casadi::GenericType* >* x4);
+casadi::Function*
+    casadi__Function__kernel_sum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::pair< int, int >* x1, double x2, int x3, std::map< std::string, casadi::GenericType* >* x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
+        double x2_ = Marshaling<double,double>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
+
+        casadi::Function ret = obj->kernel_sum(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_cholesky" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_cholesky"
+// cWrapperName: "casadi__Function__linsol_cholesky__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__Function__linsol_cholesky__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::DM ret = obj->linsol_cholesky();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__Function__linsol_cholesky__0(std::string ** err_msg, casadi::Function* obj);
+casadi::DM*
+    casadi__Function__linsol_cholesky__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::DM ret = obj->linsol_cholesky();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_cholesky" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_cholesky"
+// cWrapperName: "casadi__Function__linsol_cholesky__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__Function__linsol_cholesky__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::DM ret = obj->linsol_cholesky(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__Function__linsol_cholesky__1(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::DM*
+    casadi__Function__linsol_cholesky__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::DM ret = obj->linsol_cholesky(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_cholesky" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_cholesky"
+// cWrapperName: "casadi__Function__linsol_cholesky__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__Function__linsol_cholesky__2(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::DM ret = obj->linsol_cholesky(x0_, x1_);"
+// params: [(CBool,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::DM*
+    casadi__Function__linsol_cholesky__2(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::DM*
+    casadi__Function__linsol_cholesky__2(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::DM ret = obj->linsol_cholesky(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_cholesky_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_cholesky_sparsity"
+// cWrapperName: "casadi__Function__linsol_cholesky_sparsity__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__linsol_cholesky_sparsity__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Sparsity ret = obj->linsol_cholesky_sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Function__linsol_cholesky_sparsity__0(std::string ** err_msg, casadi::Function* obj);
+casadi::Sparsity*
+    casadi__Function__linsol_cholesky_sparsity__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Sparsity ret = obj->linsol_cholesky_sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_cholesky_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_cholesky_sparsity"
+// cWrapperName: "casadi__Function__linsol_cholesky_sparsity__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__linsol_cholesky_sparsity__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->linsol_cholesky_sparsity(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__linsol_cholesky_sparsity__1(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Sparsity*
+    casadi__Function__linsol_cholesky_sparsity__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->linsol_cholesky_sparsity(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_cholesky_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_cholesky_sparsity"
+// cWrapperName: "casadi__Function__linsol_cholesky_sparsity__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__linsol_cholesky_sparsity__2(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->linsol_cholesky_sparsity(x0_, x1_);"
+// params: [(CBool,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__linsol_cholesky_sparsity__2(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::Sparsity*
+    casadi__Function__linsol_cholesky_sparsity__2(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->linsol_cholesky_sparsity(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_solve" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_solve"
+// cWrapperName: "casadi__Function__linsol_solve__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__Function__linsol_solve__0(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1)"
+// call: "        casadi::MX ret = obj->linsol_solve(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__Function__linsol_solve__0(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1);
+casadi::MX*
+    casadi__Function__linsol_solve__0(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
+
+        casadi::MX ret = obj->linsol_solve(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "linsol_solve" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::linsol_solve"
+// cWrapperName: "casadi__Function__linsol_solve__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__Function__linsol_solve__1(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1, int x2)"
+// call: "        casadi::MX ret = obj->linsol_solve(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__Function__linsol_solve__1(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1, int x2);
+casadi::MX*
+    casadi__Function__linsol_solve__1(std::string ** err_msg, casadi::Function* obj, casadi::MX* x0, casadi::MX* x1, int x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::MX ret = obj->linsol_solve(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__map__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
+// call: "        casadi::Function ret = obj->map(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__map__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2);
+casadi::Function*
+    casadi__Function__map__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::Function ret = obj->map(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::map< std::string, casadi::GenericType* >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__map__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::map< std::string, casadi::GenericType* >* x3)"
+// call: "        casadi::Function ret = obj->map(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__map__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::map< std::string, casadi::GenericType* >* x3);
+casadi::Function*
+    casadi__Function__map__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::map< std::string, casadi::GenericType* >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        std::map< std::string, casadi::GenericType > x3_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x3);
+
+        casadi::Function ret = obj->map(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__map__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4)"
+// call: "        casadi::Function ret = obj->map(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__map__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4);
+casadi::Function*
+    casadi__Function__map__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
+
+        casadi::Function ret = obj->map(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__map__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5)"
+// call: "        casadi::Function ret = obj->map(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__map__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5);
+casadi::Function*
+    casadi__Function__map__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, std::vector< int >* x3, std::vector< int >* x4, std::map< std::string, casadi::GenericType* >* x5){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
+        std::map< std::string, casadi::GenericType > x5_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x5);
+
+        casadi::Function ret = obj->map(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0)"
+// args: "(x0_)"
+// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::map< std::string, casadi::MX* >*"
+// proto: "std::map< std::string, casadi::MX* >*\n    casadi__Function__map__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0)"
+// call: "        std::map< std::string, casadi::MX > ret = obj->map(x0_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False)]
+extern "C"
+std::map< std::string, casadi::MX* >*
+    casadi__Function__map__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0);
+std::map< std::string, casadi::MX* >*
+    casadi__Function__map__4(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0){
+    try {
+        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
+
+        std::map< std::string, casadi::MX > ret = obj->map(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::map< std::string, casadi::MX* >*"
+// proto: "std::map< std::string, casadi::MX* >*\n    casadi__Function__map__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::string* x1)"
+// call: "        std::map< std::string, casadi::MX > ret = obj->map(x0_, x1_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::map< std::string, casadi::MX* >*
+    casadi__Function__map__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::string* x1);
+std::map< std::string, casadi::MX* >*
+    casadi__Function__map__5(std::string ** err_msg, casadi::Function* obj, std::map< std::string, casadi::MX* >* x0, std::string* x1){
+    try {
+        std::map< std::string, casadi::MX > x0_ = Marshaling<std::map< std::string, casadi::MX >,std::map< std::string, casadi::MX* >*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        std::map< std::string, casadi::MX > ret = obj->map(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::map< std::string, casadi::MX* >*, std::map< std::string, casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__Function__map__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
+// call: "        std::vector< casadi::MX > ret = obj->map(x0_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__Function__map__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0);
+std::vector< casadi::MX* >*
+    casadi__Function__map__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+
+        std::vector< casadi::MX > ret = obj->map(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "map" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::map"
+// cWrapperName: "casadi__Function__map__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__Function__map__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
+// call: "        std::vector< casadi::MX > ret = obj->map(x0_, x1_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__Function__map__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1);
+std::vector< casadi::MX* >*
+    casadi__Function__map__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        std::vector< casadi::MX > ret = obj->map(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mapaccum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mapaccum"
+// cWrapperName: "casadi__Function__mapaccum__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__mapaccum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        casadi::Function ret = obj->mapaccum(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__mapaccum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+casadi::Function*
+    casadi__Function__mapaccum__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        casadi::Function ret = obj->mapaccum(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mapaccum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mapaccum"
+// cWrapperName: "casadi__Function__mapaccum__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::map< std::string, casadi::GenericType* >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__mapaccum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::map< std::string, casadi::GenericType* >* x4)"
+// call: "        casadi::Function ret = obj->mapaccum(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__mapaccum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::map< std::string, casadi::GenericType* >* x4);
+casadi::Function*
+    casadi__Function__mapaccum__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::map< std::string, casadi::GenericType* >* x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        std::map< std::string, casadi::GenericType > x4_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x4);
+
+        casadi::Function ret = obj->mapaccum(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mapaccum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mapaccum"
+// cWrapperName: "casadi__Function__mapaccum__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__mapaccum__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// call: "        casadi::Function ret = obj->mapaccum(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__mapaccum__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
+casadi::Function*
+    casadi__Function__mapaccum__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->mapaccum(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mapaccum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mapaccum"
+// cWrapperName: "casadi__Function__mapaccum__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__mapaccum__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2)"
+// call: "        casadi::Function ret = obj->mapaccum(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__mapaccum__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2);
+casadi::Function*
+    casadi__Function__mapaccum__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, std::map< std::string, casadi::GenericType* >* x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
+
+        casadi::Function ret = obj->mapaccum(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mapsum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mapsum"
+// cWrapperName: "casadi__Function__mapsum__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__Function__mapsum__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
+// call: "        std::vector< casadi::MX > ret = obj->mapsum(x0_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__Function__mapsum__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0);
+std::vector< casadi::MX* >*
+    casadi__Function__mapsum__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+
+        std::vector< casadi::MX > ret = obj->mapsum(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mapsum" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mapsum"
+// cWrapperName: "casadi__Function__mapsum__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__Function__mapsum__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1)"
+// call: "        std::vector< casadi::MX > ret = obj->mapsum(x0_, x1_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__Function__mapsum__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1);
+std::vector< casadi::MX* >*
+    casadi__Function__mapsum__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::string* x1){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        std::vector< casadi::MX > ret = obj->mapsum(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mx_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mx_in"
+// cWrapperName: "casadi__Function__mx_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__Function__mx_in__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::vector< casadi::MX > ret = obj->mx_in();"
+// params: []
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__Function__mx_in__0(std::string ** err_msg, casadi::Function* obj);
+std::vector< casadi::MX* >*
+    casadi__Function__mx_in__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::vector< casadi::MX > ret = obj->mx_in();
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mx_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mx_in"
+// cWrapperName: "casadi__Function__mx_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__Function__mx_in__1(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->mx_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__Function__mx_in__1(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::MX*
+    casadi__Function__mx_in__1(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->mx_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mx_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mx_in"
+// cWrapperName: "casadi__Function__mx_in__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__Function__mx_in__2(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::MX ret = obj->mx_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__Function__mx_in__2(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::MX*
+    casadi__Function__mx_in__2(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = obj->mx_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mx_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mx_out"
+// cWrapperName: "casadi__Function__mx_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__Function__mx_out__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::vector< casadi::MX > ret = obj->mx_out();"
+// params: []
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__Function__mx_out__0(std::string ** err_msg, casadi::Function* obj);
+std::vector< casadi::MX* >*
+    casadi__Function__mx_out__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::vector< casadi::MX > ret = obj->mx_out();
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mx_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mx_out"
+// cWrapperName: "casadi__Function__mx_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__Function__mx_out__1(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->mx_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__Function__mx_out__1(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::MX*
+    casadi__Function__mx_out__1(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->mx_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mx_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::mx_out"
+// cWrapperName: "casadi__Function__mx_out__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__Function__mx_out__2(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::MX ret = obj->mx_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__Function__mx_out__2(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::MX*
+    casadi__Function__mx_out__2(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = obj->mx_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::n_in"
+// cWrapperName: "casadi__Function__n_in"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__n_in(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->n_in();"
+// params: []
+extern "C"
+int
+    casadi__Function__n_in(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__n_in(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->n_in();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_nodes" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::n_nodes"
+// cWrapperName: "casadi__Function__n_nodes"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__n_nodes(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->n_nodes();"
+// params: []
+extern "C"
+int
+    casadi__Function__n_nodes(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__n_nodes(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->n_nodes();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::n_out"
+// cWrapperName: "casadi__Function__n_out"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__n_out(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->n_out();"
+// params: []
+extern "C"
+int
+    casadi__Function__n_out(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__n_out(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->n_out();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::name"
+// cWrapperName: "casadi__Function__name"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Function__name(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::string ret = obj->name();"
+// params: []
+extern "C"
+std::string*
+    casadi__Function__name(std::string ** err_msg, casadi::Function* obj);
+std::string*
+    casadi__Function__name(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::string ret = obj->name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::name_in"
+// cWrapperName: "casadi__Function__name_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Function__name_in__0(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        std::string ret = obj->name_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::string*
+    casadi__Function__name_in__0(std::string ** err_msg, casadi::Function* obj, int x0);
+std::string*
+    casadi__Function__name_in__0(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::string ret = obj->name_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::name_in"
+// cWrapperName: "casadi__Function__name_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: StdVec StdString
+// cWrapperRetType: "std::vector< std::string* >*"
+// proto: "std::vector< std::string* >*\n    casadi__Function__name_in__1(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::vector< std::string > ret = obj->name_in();"
+// params: []
+extern "C"
+std::vector< std::string* >*
+    casadi__Function__name_in__1(std::string ** err_msg, casadi::Function* obj);
+std::vector< std::string* >*
+    casadi__Function__name_in__1(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::vector< std::string > ret = obj->name_in();
+
+        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::name_out"
+// cWrapperName: "casadi__Function__name_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Function__name_out__0(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        std::string ret = obj->name_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::string*
+    casadi__Function__name_out__0(std::string ** err_msg, casadi::Function* obj, int x0);
+std::string*
+    casadi__Function__name_out__0(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::string ret = obj->name_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::name_out"
+// cWrapperName: "casadi__Function__name_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: StdVec StdString
+// cWrapperRetType: "std::vector< std::string* >*"
+// proto: "std::vector< std::string* >*\n    casadi__Function__name_out__1(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::vector< std::string > ret = obj->name_out();"
+// params: []
+extern "C"
+std::vector< std::string* >*
+    casadi__Function__name_out__1(std::string ** err_msg, casadi::Function* obj);
+std::vector< std::string* >*
+    casadi__Function__name_out__1(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::vector< std::string > ret = obj->name_out();
+
+        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::nnz_in"
+// cWrapperName: "casadi__Function__nnz_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__nnz_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->nnz_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__nnz_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__nnz_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->nnz_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::nnz_in"
+// cWrapperName: "casadi__Function__nnz_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__nnz_in__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->nnz_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__nnz_in__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__nnz_in__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->nnz_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::nnz_in"
+// cWrapperName: "casadi__Function__nnz_in__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__nnz_in__2(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->nnz_in();"
+// params: []
+extern "C"
+int
+    casadi__Function__nnz_in__2(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__nnz_in__2(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->nnz_in();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::nnz_out"
+// cWrapperName: "casadi__Function__nnz_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__nnz_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->nnz_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__nnz_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__nnz_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->nnz_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::nnz_out"
+// cWrapperName: "casadi__Function__nnz_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__nnz_out__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->nnz_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__nnz_out__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__nnz_out__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->nnz_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::nnz_out"
+// cWrapperName: "casadi__Function__nnz_out__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__nnz_out__2(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->nnz_out();"
+// params: []
+extern "C"
+int
+    casadi__Function__nnz_out__2(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__nnz_out__2(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->nnz_out();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::numel_in"
+// cWrapperName: "casadi__Function__numel_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__numel_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->numel_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__numel_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__numel_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->numel_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::numel_in"
+// cWrapperName: "casadi__Function__numel_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__numel_in__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->numel_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__numel_in__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__numel_in__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->numel_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::numel_in"
+// cWrapperName: "casadi__Function__numel_in__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__numel_in__2(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->numel_in();"
+// params: []
+extern "C"
+int
+    casadi__Function__numel_in__2(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__numel_in__2(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->numel_in();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::numel_out"
+// cWrapperName: "casadi__Function__numel_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__numel_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->numel_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__numel_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__numel_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->numel_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::numel_out"
+// cWrapperName: "casadi__Function__numel_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__numel_out__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->numel_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__numel_out__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__numel_out__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->numel_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::numel_out"
+// cWrapperName: "casadi__Function__numel_out__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__numel_out__2(std::string ** err_msg, casadi::Function* obj)"
+// call: "        int ret = obj->numel_out();"
+// params: []
+extern "C"
+int
+    casadi__Function__numel_out__2(std::string ** err_msg, casadi::Function* obj);
+int
+    casadi__Function__numel_out__2(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        int ret = obj->numel_out();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "printDimensions" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::printDimensions"
+// cWrapperName: "casadi__Function__printDimensions"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__printDimensions(std::string ** err_msg, casadi::Function* obj)"
+// call: "        obj->printDimensions();"
+// params: []
+extern "C"
+void
+    casadi__Function__printDimensions(std::string ** err_msg, casadi::Function* obj);
+void
+    casadi__Function__printDimensions(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        obj->printDimensions();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "printOption" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::printOption"
+// cWrapperName: "casadi__Function__printOption"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__printOption(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        obj->printOption(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__printOption(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+void
+    casadi__Function__printOption(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->printOption(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "printOptions" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::printOptions"
+// cWrapperName: "casadi__Function__printOptions"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__printOptions(std::string ** err_msg, casadi::Function* obj)"
+// call: "        obj->printOptions();"
+// params: []
+extern "C"
+void
+    casadi__Function__printOptions(std::string ** err_msg, casadi::Function* obj);
+void
+    casadi__Function__printOptions(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        obj->printOptions();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "qpsol_debug" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::qpsol_debug"
+// cWrapperName: "casadi__Function__qpsol_debug"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__qpsol_debug(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        obj->qpsol_debug(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__qpsol_debug(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+void
+    casadi__Function__qpsol_debug(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->qpsol_debug(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "release" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::release"
+// cWrapperName: "casadi__Function__release"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__release(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        obj->release(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__release(std::string ** err_msg, casadi::Function* obj, int x0);
+void
+    casadi__Function__release(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        obj->release(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "removeMonitor" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::removeMonitor"
+// cWrapperName: "casadi__Function__removeMonitor"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        obj->removeMonitor(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+void
+    casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->removeMonitor(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__reverse__0(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Function ret = obj->reverse(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__reverse__0(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Function*
+    casadi__Function__reverse__0(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Function ret = obj->reverse(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__reverse__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3);
+void
+    casadi__Function__reverse__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x1);
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+
+        obj->reverse(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__reverse__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4);
+void
+    casadi__Function__reverse__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x1);
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->reverse(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DM")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__reverse__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5);
+void
+    casadi__Function__reverse__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DM* >* x0, std::vector< casadi::DM* >* x1, std::vector< std::vector< casadi::DM* >* >* x2, std::vector< std::vector< casadi::DM* >* >** x3, int x4, int x5){
+    try {
+        std::vector< casadi::DM > x0_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x0);
+        std::vector< casadi::DM > x1_ = Marshaling<std::vector< casadi::DM >,std::vector< casadi::DM* >*>::marshal(x1);
+        std::vector< std::vector< casadi::DM > > x2_ = Marshaling<std::vector< std::vector< casadi::DM > >,std::vector< std::vector< casadi::DM* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::DM > > x3_ = std::vector< std::vector< casadi::DM > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+        bool x5_ = Marshaling<bool,int>::marshal(x5);
+
+        obj->reverse(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::DM* >* >*, std::vector< std::vector< casadi::DM > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__reverse__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3);
+void
+    casadi__Function__reverse__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+
+        obj->reverse(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__reverse__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4);
+void
+    casadi__Function__reverse__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->reverse(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__reverse__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5);
+void
+    casadi__Function__reverse__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >** x3, int x4, int x5){
+    try {
+        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
+        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::SX > > x3_ = std::vector< std::vector< casadi::SX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+        bool x5_ = Marshaling<bool,int>::marshal(x5);
+
+        obj->reverse(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True)]
+extern "C"
+void
+    casadi__Function__reverse__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3);
+void
+    casadi__Function__reverse__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+
+        obj->reverse(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__reverse__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4);
+void
+    casadi__Function__reverse__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->reverse(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::reverse"
+// cWrapperName: "casadi__Function__reverse__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__reverse__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5)"
+// call: "        obj->reverse(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput False),(Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),SwigOutput False),(Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),SwigOutput True),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__reverse__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5);
+void
+    casadi__Function__reverse__9(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >** x3, int x4, int x5){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
+        std::vector< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
+        std::vector< std::vector< casadi::MX > > x3_ = std::vector< std::vector< casadi::MX > >();  // Swig output
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+        bool x5_ = Marshaling<bool,int>::marshal(x5);
+
+        obj->reverse(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        *x3 = WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( x3_ );
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "rootfinder_fun" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::rootfinder_fun"
+// cWrapperName: "casadi__Function__rootfinder_fun"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__rootfinder_fun(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->rootfinder_fun();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__rootfinder_fun(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__rootfinder_fun(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->rootfinder_fun();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "rootfinder_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::rootfinder_jac"
+// cWrapperName: "casadi__Function__rootfinder_jac"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__rootfinder_jac(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->rootfinder_jac();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__rootfinder_jac(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__rootfinder_jac(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->rootfinder_jac();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "rootfinder_linsol" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::rootfinder_linsol"
+// cWrapperName: "casadi__Function__rootfinder_linsol"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__rootfinder_linsol(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->rootfinder_linsol();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__rootfinder_linsol(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__rootfinder_linsol(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->rootfinder_linsol();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "setFullJacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::setFullJacobian"
+// cWrapperName: "casadi__Function__setFullJacobian"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
+// call: "        obj->setFullJacobian(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0);
+void
+    casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        obj->setFullJacobian(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "setJacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::setJacobian"
+// cWrapperName: "casadi__Function__setJacobian__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
+// call: "        obj->setJacobian(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0);
+void
+    casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        obj->setJacobian(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "setJacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::setJacobian"
+// cWrapperName: "casadi__Function__setJacobian__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
+// call: "        obj->setJacobian(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1);
+void
+    casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->setJacobian(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "setJacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::setJacobian"
+// cWrapperName: "casadi__Function__setJacobian__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
+// call: "        obj->setJacobian(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2);
+void
+    casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        obj->setJacobian(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "setJacobian" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::setJacobian"
+// cWrapperName: "casadi__Function__setJacobian__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3)"
+// call: "        obj->setJacobian(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3);
+void
+    casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->setJacobian(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_forward" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_forward"
+// cWrapperName: "casadi__Function__set_forward"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_forward(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
+// call: "        obj->set_forward(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_forward(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1);
+void
+    casadi__Function__set_forward(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->set_forward(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2);
+void
+    casadi__Function__set_jac_sparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3);
+void
+    casadi__Function__set_jac_sparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2);
+void
+    casadi__Function__set_jac_sparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3);
+void
+    casadi__Function__set_jac_sparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2);
+void
+    casadi__Function__set_jac_sparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3);
+void
+    casadi__Function__set_jac_sparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2);
+void
+    casadi__Function__set_jac_sparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_jac_sparsity" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_jac_sparsity"
+// cWrapperName: "casadi__Function__set_jac_sparsity__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_jac_sparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3)"
+// call: "        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_jac_sparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3);
+void
+    casadi__Function__set_jac_sparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        obj->set_jac_sparsity(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_reverse" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::set_reverse"
+// cWrapperName: "casadi__Function__set_reverse"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Function__set_reverse(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
+// call: "        obj->set_reverse(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Function__set_reverse(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1);
+void
+    casadi__Function__set_reverse(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->set_reverse(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "size1_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size1_in"
+// cWrapperName: "casadi__Function__size1_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size1_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->size1_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size1_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__size1_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->size1_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size1_in"
+// cWrapperName: "casadi__Function__size1_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size1_in__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->size1_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size1_in__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__size1_in__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size1_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size1_out"
+// cWrapperName: "casadi__Function__size1_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size1_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->size1_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size1_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__size1_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->size1_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size1_out"
+// cWrapperName: "casadi__Function__size1_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size1_out__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->size1_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size1_out__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__size1_out__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size1_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size2_in"
+// cWrapperName: "casadi__Function__size2_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size2_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->size2_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size2_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__size2_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->size2_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size2_in"
+// cWrapperName: "casadi__Function__size2_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size2_in__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->size2_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size2_in__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__size2_in__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size2_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size2_out"
+// cWrapperName: "casadi__Function__size2_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size2_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        int ret = obj->size2_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size2_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+int
+    casadi__Function__size2_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        int ret = obj->size2_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size2_out"
+// cWrapperName: "casadi__Function__size2_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__size2_out__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        int ret = obj->size2_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__size2_out__1(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__size2_out__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size2_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size_in"
+// cWrapperName: "casadi__Function__size_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__Function__size_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        std::pair< int, int > ret = obj->size_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::pair< int, int >*
+    casadi__Function__size_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+std::pair< int, int >*
+    casadi__Function__size_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::pair< int, int > ret = obj->size_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size_in"
+// cWrapperName: "casadi__Function__size_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__Function__size_in__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        std::pair< int, int > ret = obj->size_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::pair< int, int >*
+    casadi__Function__size_in__1(std::string ** err_msg, casadi::Function* obj, int x0);
+std::pair< int, int >*
+    casadi__Function__size_in__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::pair< int, int > ret = obj->size_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size_out"
+// cWrapperName: "casadi__Function__size_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__Function__size_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        std::pair< int, int > ret = obj->size_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::pair< int, int >*
+    casadi__Function__size_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+std::pair< int, int >*
+    casadi__Function__size_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::pair< int, int > ret = obj->size_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::size_out"
+// cWrapperName: "casadi__Function__size_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__Function__size_out__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        std::pair< int, int > ret = obj->size_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::pair< int, int >*
+    casadi__Function__size_out__1(std::string ** err_msg, casadi::Function* obj, int x0);
+std::pair< int, int >*
+    casadi__Function__size_out__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::pair< int, int > ret = obj->size_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "slice" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::slice"
+// cWrapperName: "casadi__Function__slice__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__slice__0(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        casadi::Function ret = obj->slice(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__slice__0(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1);
+casadi::Function*
+    casadi__Function__slice__0(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        casadi::Function ret = obj->slice(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "slice" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::slice"
+// cWrapperName: "casadi__Function__slice__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1, std::map< std::string, casadi::GenericType* >* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__slice__1(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1, std::map< std::string, casadi::GenericType* >* x2)"
+// call: "        casadi::Function ret = obj->slice(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__slice__1(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1, std::map< std::string, casadi::GenericType* >* x2);
+casadi::Function*
+    casadi__Function__slice__1(std::string ** err_msg, casadi::Function* obj, std::vector< int >* x0, std::vector< int >* x1, std::map< std::string, casadi::GenericType* >* x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        std::map< std::string, casadi::GenericType > x2_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x2);
+
+        casadi::Function ret = obj->slice(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "spCanEvaluate" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::spCanEvaluate"
+// cWrapperName: "casadi__Function__spCanEvaluate"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        bool ret = obj->spCanEvaluate(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0);
+int
+    casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->spCanEvaluate(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_in"
+// cWrapperName: "casadi__Function__sparsity_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Sparsity ret = obj->sparsity_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Sparsity*
+    casadi__Function__sparsity_in__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->sparsity_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_in"
+// cWrapperName: "casadi__Function__sparsity_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_in__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->sparsity_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_in__1(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Sparsity*
+    casadi__Function__sparsity_in__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->sparsity_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__6(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__6(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__6(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__10"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__10(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__10(std::string ** err_msg, casadi::Function* obj);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__10(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Sparsity ret = obj->sparsity_jac();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__11"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__11(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__11(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__11(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__12"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__13"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_jac" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_jac"
+// cWrapperName: "casadi__Function__sparsity_jac__14"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_jac__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
+// call: "        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3);
+casadi::Sparsity*
+    casadi__Function__sparsity_jac__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Sparsity ret = obj->sparsity_jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_out"
+// cWrapperName: "casadi__Function__sparsity_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Sparsity ret = obj->sparsity_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Sparsity*
+    casadi__Function__sparsity_out__0(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->sparsity_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sparsity_out"
+// cWrapperName: "casadi__Function__sparsity_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Function__sparsity_out__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->sparsity_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Function__sparsity_out__1(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Sparsity*
+    casadi__Function__sparsity_out__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->sparsity_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "stats" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::stats"
+// cWrapperName: "casadi__Function__stats__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))
+// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
+// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__Function__stats__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::map< std::string, casadi::GenericType > ret = obj->stats();"
+// params: []
+extern "C"
+std::map< std::string, casadi::GenericType* >*
+    casadi__Function__stats__0(std::string ** err_msg, casadi::Function* obj);
+std::map< std::string, casadi::GenericType* >*
+    casadi__Function__stats__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::map< std::string, casadi::GenericType > ret = obj->stats();
+
+        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "stats" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::stats"
+// cWrapperName: "casadi__Function__stats__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))
+// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
+// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__Function__stats__1(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        std::map< std::string, casadi::GenericType > ret = obj->stats(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::map< std::string, casadi::GenericType* >*
+    casadi__Function__stats__1(std::string ** err_msg, casadi::Function* obj, int x0);
+std::map< std::string, casadi::GenericType* >*
+    casadi__Function__stats__1(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::map< std::string, casadi::GenericType > ret = obj->stats(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sx_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sx_in"
+// cWrapperName: "casadi__Function__sx_in__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
+// cWrapperRetType: "std::vector< casadi::SX* >*"
+// proto: "std::vector< casadi::SX* >*\n    casadi__Function__sx_in__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::vector< casadi::SX > ret = obj->sx_in();"
+// params: []
+extern "C"
+std::vector< casadi::SX* >*
+    casadi__Function__sx_in__0(std::string ** err_msg, casadi::Function* obj);
+std::vector< casadi::SX* >*
+    casadi__Function__sx_in__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::vector< casadi::SX > ret = obj->sx_in();
+
+        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sx_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sx_in"
+// cWrapperName: "casadi__Function__sx_in__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__Function__sx_in__1(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::SX ret = obj->sx_in(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__Function__sx_in__1(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::SX*
+    casadi__Function__sx_in__1(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::SX ret = obj->sx_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sx_in" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sx_in"
+// cWrapperName: "casadi__Function__sx_in__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__Function__sx_in__2(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::SX ret = obj->sx_in(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__Function__sx_in__2(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::SX*
+    casadi__Function__sx_in__2(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = obj->sx_in(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sx_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sx_out"
+// cWrapperName: "casadi__Function__sx_out__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
+// cWrapperRetType: "std::vector< casadi::SX* >*"
+// proto: "std::vector< casadi::SX* >*\n    casadi__Function__sx_out__0(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::vector< casadi::SX > ret = obj->sx_out();"
+// params: []
+extern "C"
+std::vector< casadi::SX* >*
+    casadi__Function__sx_out__0(std::string ** err_msg, casadi::Function* obj);
+std::vector< casadi::SX* >*
+    casadi__Function__sx_out__0(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::vector< casadi::SX > ret = obj->sx_out();
+
+        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sx_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sx_out"
+// cWrapperName: "casadi__Function__sx_out__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__Function__sx_out__1(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::SX ret = obj->sx_out(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__Function__sx_out__1(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::SX*
+    casadi__Function__sx_out__1(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::SX ret = obj->sx_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sx_out" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sx_out"
+// cWrapperName: "casadi__Function__sx_out__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__Function__sx_out__2(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::SX ret = obj->sx_out(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__Function__sx_out__2(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::SX*
+    casadi__Function__sx_out__2(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = obj->sx_out(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sz_arg" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sz_arg"
+// cWrapperName: "casadi__Function__sz_arg"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__Function__sz_arg(std::string ** err_msg, casadi::Function* obj)"
+// call: "        size_t ret = obj->sz_arg();"
+// params: []
+extern "C"
+size_t
+    casadi__Function__sz_arg(std::string ** err_msg, casadi::Function* obj);
+size_t
+    casadi__Function__sz_arg(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        size_t ret = obj->sz_arg();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sz_iw" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sz_iw"
+// cWrapperName: "casadi__Function__sz_iw"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__Function__sz_iw(std::string ** err_msg, casadi::Function* obj)"
+// call: "        size_t ret = obj->sz_iw();"
+// params: []
+extern "C"
+size_t
+    casadi__Function__sz_iw(std::string ** err_msg, casadi::Function* obj);
+size_t
+    casadi__Function__sz_iw(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        size_t ret = obj->sz_iw();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sz_res" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sz_res"
+// cWrapperName: "casadi__Function__sz_res"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__Function__sz_res(std::string ** err_msg, casadi::Function* obj)"
+// call: "        size_t ret = obj->sz_res();"
+// params: []
+extern "C"
+size_t
+    casadi__Function__sz_res(std::string ** err_msg, casadi::Function* obj);
+size_t
+    casadi__Function__sz_res(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        size_t ret = obj->sz_res();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sz_w" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::sz_w"
+// cWrapperName: "casadi__Function__sz_w"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__Function__sz_w(std::string ** err_msg, casadi::Function* obj)"
+// call: "        size_t ret = obj->sz_w();"
+// params: []
+extern "C"
+size_t
+    casadi__Function__sz_w(std::string ** err_msg, casadi::Function* obj);
+size_t
+    casadi__Function__sz_w(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        size_t ret = obj->sz_w();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "tangent" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::tangent"
+// cWrapperName: "casadi__Function__tangent__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->tangent(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
+casadi::Function*
+    casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->tangent(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "tangent" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::tangent"
+// cWrapperName: "casadi__Function__tangent__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
+// call: "        casadi::Function ret = obj->tangent(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
+casadi::Function*
+    casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::Function ret = obj->tangent(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "tangent" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::tangent"
+// cWrapperName: "casadi__Function__tangent__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
+// call: "        casadi::Function ret = obj->tangent(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
+casadi::Function*
+    casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Function ret = obj->tangent(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "tangent" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::tangent"
+// cWrapperName: "casadi__Function__tangent__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
+// call: "        casadi::Function ret = obj->tangent(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
+casadi::Function*
+    casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->tangent(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "tangent" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::tangent"
+// cWrapperName: "casadi__Function__tangent__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj)"
+// call: "        casadi::Function ret = obj->tangent();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj);
+casadi::Function*
+    casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        casadi::Function ret = obj->tangent();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "tangent" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::tangent"
+// cWrapperName: "casadi__Function__tangent__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0)"
+// call: "        casadi::Function ret = obj->tangent(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0);
+casadi::Function*
+    casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Function ret = obj->tangent(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "tangent" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::tangent"
+// cWrapperName: "casadi__Function__tangent__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
+// call: "        casadi::Function ret = obj->tangent(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
+casadi::Function*
+    casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Function ret = obj->tangent(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "type_name" ===============
+// class: "casadi::Function"
+// cppName: "casadi::Function::type_name"
+// cWrapperName: "casadi__Function__type_name"
+// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Function__type_name(std::string ** err_msg, casadi::Function* obj)"
+// call: "        std::string ret = obj->type_name();"
+// params: []
+extern "C"
+std::string*
+    casadi__Function__type_name(std::string ** err_msg, casadi::Function* obj);
+std::string*
+    casadi__Function__type_name(std::string ** err_msg, casadi::Function* obj){
+    try {
+
+        std::string ret = obj->type_name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "GenericExpressionCommon")===============
+// classType: UserType (Namespace ["casadi"]) (Name "GenericExpressionCommon")
+extern "C"
+void delete_casadi__GenericExpressionCommon(casadi::GenericExpressionCommon* obj);
+void delete_casadi__GenericExpressionCommon(casadi::GenericExpressionCommon* obj){
+    delete obj;
+}
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "GenericMatrixCommon")===============
+// classType: UserType (Namespace ["casadi"]) (Name "GenericMatrixCommon")
+extern "C"
+void delete_casadi__GenericMatrixCommon(casadi::GenericMatrixCommon* obj);
+void delete_casadi__GenericMatrixCommon(casadi::GenericMatrixCommon* obj){
+    delete obj;
+}
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "GenericType")===============
+// classType: UserType (Namespace ["casadi"]) (Name "GenericType")
+extern "C"
+void delete_casadi__GenericType(casadi::GenericType* obj);
+void delete_casadi__GenericType(casadi::GenericType* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, std::map< std::string, casadi::GenericType* >* x0){
+    try {
+        std::map< std::string, casadi::GenericType > x0_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg, std::vector< std::string* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, std::vector< std::string* >* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const (StdVec StdString)),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, std::vector< std::string* >* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, std::vector< std::string* >* x0){
+    try {
+        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, std::vector< double >* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, std::vector< double >* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, std::vector< double >* x0){
+    try {
+        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__4"
+// protoArgs: "(std::string ** err_msg, std::vector< std::vector< int >* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< int >* >* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const (StdVec (StdVec CInt))),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< int >* >* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< int >* >* x0){
+    try {
+        std::vector< std::vector< int > > x0_ = Marshaling<std::vector< std::vector< int > >,std::vector< std::vector< int >* >*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__5"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< int >* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< int >* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__6"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< int >* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const (StdVec CBool)),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< int >* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< int >* x0){
+    try {
+        std::vector< bool > x0_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__7"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__8"
+// protoArgs: "(std::string ** err_msg, double x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, double x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(CDouble,SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, double x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, double x0){
+    try {
+        double x0_ = Marshaling<double,double>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__9"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, int x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, int x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__10"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, int x0)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, int x0);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType"
+// cWrapperName: "casadi__GenericType__CONSTRUCTOR__11"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
+// cWrapperRetType: "casadi::GenericType*"
+// proto: "casadi::GenericType*\n    casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg)"
+// call: "        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType();"
+// params: []
+extern "C"
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg);
+casadi::GenericType*
+    casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg){
+    try {
+
+        casadi::GenericType* ret = (casadi::GenericType*)new casadi::GenericType();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_bool" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_bool"
+// cWrapperName: "casadi__GenericType__as_bool"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__as_bool(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->as_bool();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__as_bool(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__as_bool(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->as_bool();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_dict" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_dict"
+// cWrapperName: "casadi__GenericType__as_dict"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))
+// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
+// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__GenericType__as_dict(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::map< std::string, casadi::GenericType > ret = obj->as_dict();"
+// params: []
+extern "C"
+std::map< std::string, casadi::GenericType* >*
+    casadi__GenericType__as_dict(std::string ** err_msg, casadi::GenericType* obj);
+std::map< std::string, casadi::GenericType* >*
+    casadi__GenericType__as_dict(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::map< std::string, casadi::GenericType > ret = obj->as_dict();
+
+        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_double" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_double"
+// cWrapperName: "casadi__GenericType__as_double"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__GenericType__as_double(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        double ret = obj->as_double();"
+// params: []
+extern "C"
+double
+    casadi__GenericType__as_double(std::string ** err_msg, casadi::GenericType* obj);
+double
+    casadi__GenericType__as_double(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        double ret = obj->as_double();
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_double_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_double_vector"
+// cWrapperName: "casadi__GenericType__as_double_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const (StdVec CDouble)
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__GenericType__as_double_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< double > ret = obj->as_double_vector();"
+// params: []
+extern "C"
+std::vector< double >*
+    casadi__GenericType__as_double_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< double >*
+    casadi__GenericType__as_double_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< double > ret = obj->as_double_vector();
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_function" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_function"
+// cWrapperName: "casadi__GenericType__as_function"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Function"))
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__GenericType__as_function(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        casadi::Function ret = obj->as_function();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__GenericType__as_function(std::string ** err_msg, casadi::GenericType* obj);
+casadi::Function*
+    casadi__GenericType__as_function(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        casadi::Function ret = obj->as_function();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_int" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_int"
+// cWrapperName: "casadi__GenericType__as_int"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__as_int(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        int ret = obj->as_int();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__as_int(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__as_int(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        int ret = obj->as_int();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_int_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_int_vector"
+// cWrapperName: "casadi__GenericType__as_int_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const (StdVec CInt)
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__GenericType__as_int_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< int > ret = obj->as_int_vector();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__GenericType__as_int_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< int >*
+    casadi__GenericType__as_int_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< int > ret = obj->as_int_vector();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_int_vector_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_int_vector_vector"
+// cWrapperName: "casadi__GenericType__as_int_vector_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const (StdVec (StdVec CInt))
+// cWrapperRetType: "std::vector< std::vector< int >* >*"
+// proto: "std::vector< std::vector< int >* >*\n    casadi__GenericType__as_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< std::vector< int > > ret = obj->as_int_vector_vector();"
+// params: []
+extern "C"
+std::vector< std::vector< int >* >*
+    casadi__GenericType__as_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< std::vector< int >* >*
+    casadi__GenericType__as_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< std::vector< int > > ret = obj->as_int_vector_vector();
+
+        return WrapReturn< std::vector< std::vector< int >* >*, std::vector< std::vector< int > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_string" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_string"
+// cWrapperName: "casadi__GenericType__as_string"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__GenericType__as_string(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::string ret = obj->as_string();"
+// params: []
+extern "C"
+std::string*
+    casadi__GenericType__as_string(std::string ** err_msg, casadi::GenericType* obj);
+std::string*
+    casadi__GenericType__as_string(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::string ret = obj->as_string();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_string_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_string_vector"
+// cWrapperName: "casadi__GenericType__as_string_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: Const (StdVec StdString)
+// cWrapperRetType: "std::vector< std::string* >*"
+// proto: "std::vector< std::string* >*\n    casadi__GenericType__as_string_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< std::string > ret = obj->as_string_vector();"
+// params: []
+extern "C"
+std::vector< std::string* >*
+    casadi__GenericType__as_string_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< std::string* >*
+    casadi__GenericType__as_string_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< std::string > ret = obj->as_string_vector();
+
+        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "as_void_pointer" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::as_void_pointer"
+// cWrapperName: "casadi__GenericType__as_void_pointer"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__GenericType__as_void_pointer(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        obj->as_void_pointer();"
+// params: []
+extern "C"
+void
+    casadi__GenericType__as_void_pointer(std::string ** err_msg, casadi::GenericType* obj);
+void
+    casadi__GenericType__as_void_pointer(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        obj->as_void_pointer();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "getType" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::getType"
+// cWrapperName: "casadi__GenericType__getType"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CEnum (Namespace ["casadi"]) (Name "TypeID")
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        casadi::TypeID ret = obj->getType();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        casadi::TypeID ret = obj->getType();
+
+        return WrapReturn< int, casadi::TypeID >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_description" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::get_description"
+// cWrapperName: "casadi__GenericType__get_description"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::string ret = obj->get_description();"
+// params: []
+extern "C"
+std::string*
+    casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj);
+std::string*
+    casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::string ret = obj->get_description();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_bool" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_bool"
+// cWrapperName: "casadi__GenericType__is_bool"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_bool(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_bool();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_bool(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_bool(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_bool();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_dict" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_dict"
+// cWrapperName: "casadi__GenericType__is_dict"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_dict(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_dict();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_dict(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_dict(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_dict();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_double" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_double"
+// cWrapperName: "casadi__GenericType__is_double"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_double(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_double();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_double(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_double(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_double();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_double_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_double_vector"
+// cWrapperName: "casadi__GenericType__is_double_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_double_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_double_vector();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_double_vector(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_double_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_double_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_empty_vector"
+// cWrapperName: "casadi__GenericType__is_empty_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_empty_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_empty_vector();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_empty_vector(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_empty_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_empty_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_function" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_function"
+// cWrapperName: "casadi__GenericType__is_function"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_function(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_function();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_function(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_function(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_function();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_int" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_int"
+// cWrapperName: "casadi__GenericType__is_int"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_int(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_int();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_int(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_int(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_int();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_int_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_int_vector"
+// cWrapperName: "casadi__GenericType__is_int_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_int_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_int_vector();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_int_vector(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_int_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_int_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_int_vector_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_int_vector_vector"
+// cWrapperName: "casadi__GenericType__is_int_vector_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_int_vector_vector();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_int_vector_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_string" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_string"
+// cWrapperName: "casadi__GenericType__is_string"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_string(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_string();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_string(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_string(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_string();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_string_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_string_vector"
+// cWrapperName: "casadi__GenericType__is_string_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_string_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_string_vector();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_string_vector(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_string_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_string_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_void_pointer" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::is_void_pointer"
+// cWrapperName: "casadi__GenericType__is_void_pointer"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__is_void_pointer(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->is_void_pointer();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__is_void_pointer(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__is_void_pointer(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->is_void_pointer();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator !=" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::operator !="
+// cWrapperName: "casadi__GenericType__operator__nequals"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__operator__nequals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
+// call: "        bool ret = obj->operator !=(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType"))),SwigOutput False)]
+extern "C"
+int
+    casadi__GenericType__operator__nequals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0);
+int
+    casadi__GenericType__operator__nequals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0){
+    try {
+        casadi::GenericType& x0_ = Marshaling<casadi::GenericType&,casadi::GenericType*>::marshal(x0);
+
+        bool ret = obj->operator !=(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator ==" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::operator =="
+// cWrapperName: "casadi__GenericType__operator__equals"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__operator__equals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
+// call: "        bool ret = obj->operator ==(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType"))),SwigOutput False)]
+extern "C"
+int
+    casadi__GenericType__operator__equals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0);
+int
+    casadi__GenericType__operator__equals(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0){
+    try {
+        casadi::GenericType& x0_ = Marshaling<casadi::GenericType&,casadi::GenericType*>::marshal(x0);
+
+        bool ret = obj->operator ==(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_bool" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_bool"
+// cWrapperName: "casadi__GenericType__to_bool"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__to_bool(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        bool ret = obj->to_bool();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__to_bool(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__to_bool(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        bool ret = obj->to_bool();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_bool_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_bool_vector"
+// cWrapperName: "casadi__GenericType__to_bool_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdVec CBool
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__GenericType__to_bool_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< bool > ret = obj->to_bool_vector();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__GenericType__to_bool_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< int >*
+    casadi__GenericType__to_bool_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< bool > ret = obj->to_bool_vector();
+
+        return WrapReturn< std::vector< int >*, std::vector< bool > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_dict" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_dict"
+// cWrapperName: "casadi__GenericType__to_dict"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType"))
+// cWrapperRetType: "std::map< std::string, casadi::GenericType* >*"
+// proto: "std::map< std::string, casadi::GenericType* >*\n    casadi__GenericType__to_dict(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::map< std::string, casadi::GenericType > ret = obj->to_dict();"
+// params: []
+extern "C"
+std::map< std::string, casadi::GenericType* >*
+    casadi__GenericType__to_dict(std::string ** err_msg, casadi::GenericType* obj);
+std::map< std::string, casadi::GenericType* >*
+    casadi__GenericType__to_dict(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::map< std::string, casadi::GenericType > ret = obj->to_dict();
+
+        return WrapReturn< std::map< std::string, casadi::GenericType* >*, std::map< std::string, casadi::GenericType > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_double" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_double"
+// cWrapperName: "casadi__GenericType__to_double"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__GenericType__to_double(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        double ret = obj->to_double();"
+// params: []
+extern "C"
+double
+    casadi__GenericType__to_double(std::string ** err_msg, casadi::GenericType* obj);
+double
+    casadi__GenericType__to_double(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        double ret = obj->to_double();
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_double_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_double_vector"
+// cWrapperName: "casadi__GenericType__to_double_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdVec CDouble
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >*\n    casadi__GenericType__to_double_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< double > ret = obj->to_double_vector();"
+// params: []
+extern "C"
+std::vector< double >*
+    casadi__GenericType__to_double_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< double >*
+    casadi__GenericType__to_double_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< double > ret = obj->to_double_vector();
+
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_function" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_function"
+// cWrapperName: "casadi__GenericType__to_function"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__GenericType__to_function(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        casadi::Function ret = obj->to_function();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__GenericType__to_function(std::string ** err_msg, casadi::GenericType* obj);
+casadi::Function*
+    casadi__GenericType__to_function(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        casadi::Function ret = obj->to_function();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_int" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_int"
+// cWrapperName: "casadi__GenericType__to_int"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GenericType__to_int(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        int ret = obj->to_int();"
+// params: []
+extern "C"
+int
+    casadi__GenericType__to_int(std::string ** err_msg, casadi::GenericType* obj);
+int
+    casadi__GenericType__to_int(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        int ret = obj->to_int();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_int_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_int_vector"
+// cWrapperName: "casadi__GenericType__to_int_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__GenericType__to_int_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< int > ret = obj->to_int_vector();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__GenericType__to_int_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< int >*
+    casadi__GenericType__to_int_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< int > ret = obj->to_int_vector();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_int_vector_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_int_vector_vector"
+// cWrapperName: "casadi__GenericType__to_int_vector_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdVec (StdVec CInt)
+// cWrapperRetType: "std::vector< std::vector< int >* >*"
+// proto: "std::vector< std::vector< int >* >*\n    casadi__GenericType__to_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< std::vector< int > > ret = obj->to_int_vector_vector();"
+// params: []
+extern "C"
+std::vector< std::vector< int >* >*
+    casadi__GenericType__to_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< std::vector< int >* >*
+    casadi__GenericType__to_int_vector_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< std::vector< int > > ret = obj->to_int_vector_vector();
+
+        return WrapReturn< std::vector< std::vector< int >* >*, std::vector< std::vector< int > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_string" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_string"
+// cWrapperName: "casadi__GenericType__to_string"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__GenericType__to_string(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::string ret = obj->to_string();"
+// params: []
+extern "C"
+std::string*
+    casadi__GenericType__to_string(std::string ** err_msg, casadi::GenericType* obj);
+std::string*
+    casadi__GenericType__to_string(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::string ret = obj->to_string();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_string_vector" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_string_vector"
+// cWrapperName: "casadi__GenericType__to_string_vector"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: StdVec StdString
+// cWrapperRetType: "std::vector< std::string* >*"
+// proto: "std::vector< std::string* >*\n    casadi__GenericType__to_string_vector(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        std::vector< std::string > ret = obj->to_string_vector();"
+// params: []
+extern "C"
+std::vector< std::string* >*
+    casadi__GenericType__to_string_vector(std::string ** err_msg, casadi::GenericType* obj);
+std::vector< std::string* >*
+    casadi__GenericType__to_string_vector(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        std::vector< std::string > ret = obj->to_string_vector();
+
+        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "to_void_pointer" ===============
+// class: "casadi::GenericType"
+// cppName: "casadi::GenericType::to_void_pointer"
+// cWrapperName: "casadi__GenericType__to_void_pointer"
+// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__GenericType__to_void_pointer(std::string ** err_msg, casadi::GenericType* obj)"
+// call: "        obj->to_void_pointer();"
+// params: []
+extern "C"
+void
+    casadi__GenericType__to_void_pointer(std::string ** err_msg, casadi::GenericType* obj);
+void
+    casadi__GenericType__to_void_pointer(std::string ** err_msg, casadi::GenericType* obj){
+    try {
+
+        obj->to_void_pointer();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "GlobalOptions")===============
+// classType: UserType (Namespace ["casadi"]) (Name "GlobalOptions")
+extern "C"
+void delete_casadi__GlobalOptions(casadi::GlobalOptions* obj);
+void delete_casadi__GlobalOptions(casadi::GlobalOptions* obj){
+    delete obj;
+}
+
+// ================== Static method: "getCasadiPath" ===============
+// class: "casadi::GlobalOptions"
+// cppName: "casadi::GlobalOptions::getCasadiPath"
+// cWrapperName: "casadi__GlobalOptions__getCasadiPath"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__GlobalOptions__getCasadiPath(std::string ** err_msg)"
+// call: "        std::string ret = casadi::GlobalOptions::getCasadiPath();"
+// params: []
+extern "C"
+std::string*
+    casadi__GlobalOptions__getCasadiPath(std::string ** err_msg);
+std::string*
+    casadi__GlobalOptions__getCasadiPath(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::GlobalOptions::getCasadiPath();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getHierarchicalSparsity" ===============
+// class: "casadi::GlobalOptions"
+// cppName: "casadi::GlobalOptions::getHierarchicalSparsity"
+// cWrapperName: "casadi__GlobalOptions__getHierarchicalSparsity"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GlobalOptions__getHierarchicalSparsity(std::string ** err_msg)"
+// call: "        bool ret = casadi::GlobalOptions::getHierarchicalSparsity();"
+// params: []
+extern "C"
+int
+    casadi__GlobalOptions__getHierarchicalSparsity(std::string ** err_msg);
+int
+    casadi__GlobalOptions__getHierarchicalSparsity(std::string ** err_msg){
+    try {
+
+        bool ret = casadi::GlobalOptions::getHierarchicalSparsity();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "getSimplificationOnTheFly" ===============
+// class: "casadi::GlobalOptions"
+// cppName: "casadi::GlobalOptions::getSimplificationOnTheFly"
+// cWrapperName: "casadi__GlobalOptions__getSimplificationOnTheFly"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__GlobalOptions__getSimplificationOnTheFly(std::string ** err_msg)"
+// call: "        bool ret = casadi::GlobalOptions::getSimplificationOnTheFly();"
+// params: []
+extern "C"
+int
+    casadi__GlobalOptions__getSimplificationOnTheFly(std::string ** err_msg);
+int
+    casadi__GlobalOptions__getSimplificationOnTheFly(std::string ** err_msg){
+    try {
+
+        bool ret = casadi::GlobalOptions::getSimplificationOnTheFly();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "setCasadiPath" ===============
+// class: "casadi::GlobalOptions"
+// cppName: "casadi::GlobalOptions::setCasadiPath"
+// cWrapperName: "casadi__GlobalOptions__setCasadiPath"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__GlobalOptions__setCasadiPath(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::GlobalOptions::setCasadiPath(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__GlobalOptions__setCasadiPath(std::string ** err_msg, std::string* x0);
+void
+    casadi__GlobalOptions__setCasadiPath(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::GlobalOptions::setCasadiPath(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setHierarchicalSparsity" ===============
+// class: "casadi::GlobalOptions"
+// cppName: "casadi::GlobalOptions::setHierarchicalSparsity"
+// cWrapperName: "casadi__GlobalOptions__setHierarchicalSparsity"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__GlobalOptions__setHierarchicalSparsity(std::string ** err_msg, int x0)"
+// call: "        casadi::GlobalOptions::setHierarchicalSparsity(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__GlobalOptions__setHierarchicalSparsity(std::string ** err_msg, int x0);
+void
+    casadi__GlobalOptions__setHierarchicalSparsity(std::string ** err_msg, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::GlobalOptions::setHierarchicalSparsity(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setSimplificationOnTheFly" ===============
+// class: "casadi::GlobalOptions"
+// cppName: "casadi::GlobalOptions::setSimplificationOnTheFly"
+// cWrapperName: "casadi__GlobalOptions__setSimplificationOnTheFly"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__GlobalOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0)"
+// call: "        casadi::GlobalOptions::setSimplificationOnTheFly(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__GlobalOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0);
+void
+    casadi__GlobalOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::GlobalOptions::setSimplificationOnTheFly(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "IM")===============
+// classType: UserType (Namespace ["casadi"]) (Name "IM")
+extern "C"
+void delete_casadi__IM(casadi::IM* obj);
+void delete_casadi__IM(casadi::IM* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::vector< casadi::SXElem* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SXElem* >* x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElem")))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SXElem* >* x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SXElem* >* x0){
+    try {
+        std::vector< casadi::SXElem > x0_ = Marshaling<std::vector< casadi::SXElem >,std::vector< casadi::SXElem* >*>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__1(std::string ** err_msg, casadi::SX* x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__1(std::string ** err_msg, casadi::SX* x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__1(std::string ** err_msg, casadi::SX* x0){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__2(std::string ** err_msg, std::vector< double >* x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__2(std::string ** err_msg, std::vector< double >* x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__2(std::string ** err_msg, std::vector< double >* x0){
+    try {
+        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, casadi::DM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__3(std::string ** err_msg, casadi::DM* x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__3(std::string ** err_msg, casadi::DM* x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__3(std::string ** err_msg, casadi::DM* x0){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__4"
+// protoArgs: "(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(Ref (Const (StdVec (StdVec CDouble))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0){
+    try {
+        std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__5"
+// protoArgs: "(std::string ** err_msg, double x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__5(std::string ** err_msg, double x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(CDouble,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__5(std::string ** err_msg, double x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__5(std::string ** err_msg, double x0){
+    try {
+        double x0_ = Marshaling<double,double>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__6"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::IM* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::IM* x1)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::IM* x1);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::IM* x1){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        casadi::IM& x1_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x1);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__7"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__8"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__9"
+// protoArgs: "(std::string ** err_msg, casadi::IM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__9(std::string ** err_msg, casadi::IM* x0)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__9(std::string ** err_msg, casadi::IM* x0);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__9(std::string ** err_msg, casadi::IM* x0){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM"
+// cWrapperName: "casadi__IM__CONSTRUCTOR__10"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__CONSTRUCTOR__10(std::string ** err_msg)"
+// call: "        casadi::IM* ret = (casadi::IM*)new casadi::IM();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__10(std::string ** err_msg);
+casadi::IM*
+    casadi__IM__CONSTRUCTOR__10(std::string ** err_msg){
+    try {
+
+        casadi::IM* ret = (casadi::IM*)new casadi::IM();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "T" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::T"
+// cWrapperName: "casadi__IM__T"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__T(std::string ** err_msg, casadi::IM* obj)"
+// call: "        casadi::IM ret = obj->T();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__T(std::string ** err_msg, casadi::IM* obj);
+casadi::IM*
+    casadi__IM__T(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        casadi::IM ret = obj->T();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "__nonzero__" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::__nonzero__"
+// cWrapperName: "casadi__IM____nonzero__"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM____nonzero__(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->__nonzero__();"
+// params: []
+extern "C"
+int
+    casadi__IM____nonzero__(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM____nonzero__(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->__nonzero__();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "binary" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::binary"
+// cWrapperName: "casadi__IM__binary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__binary(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// call: "        casadi::IM ret = casadi::IM::binary(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__binary(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2);
+casadi::IM*
+    casadi__IM__binary(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::IM& x1_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::binary(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "clear" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::clear"
+// cWrapperName: "casadi__IM__clear"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__clear(std::string ** err_msg, casadi::IM* obj)"
+// call: "        obj->clear();"
+// params: []
+extern "C"
+void
+    casadi__IM__clear(std::string ** err_msg, casadi::IM* obj);
+void
+    casadi__IM__clear(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        obj->clear();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "colind" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::colind"
+// cWrapperName: "casadi__IM__colind"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__colind(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        int ret = obj->colind(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__IM__colind(std::string ** err_msg, casadi::IM* obj, int x0);
+int
+    casadi__IM__colind(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->colind(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::dep"
+// cWrapperName: "casadi__IM__dep__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__dep__0(std::string ** err_msg, casadi::IM* obj)"
+// call: "        casadi::IM ret = obj->dep();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__dep__0(std::string ** err_msg, casadi::IM* obj);
+casadi::IM*
+    casadi__IM__dep__0(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        casadi::IM ret = obj->dep();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::dep"
+// cWrapperName: "casadi__IM__dep__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__dep__1(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        casadi::IM ret = obj->dep(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__dep__1(std::string ** err_msg, casadi::IM* obj, int x0);
+casadi::IM*
+    casadi__IM__dep__1(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM ret = obj->dep(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dim" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::dim"
+// cWrapperName: "casadi__IM__dim"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__IM__dim(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::string ret = obj->dim();"
+// params: []
+extern "C"
+std::string*
+    casadi__IM__dim(std::string ** err_msg, casadi::IM* obj);
+std::string*
+    casadi__IM__dim(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::string ret = obj->dim();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "element_hash" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::element_hash"
+// cWrapperName: "casadi__IM__element_hash"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__IM__element_hash(std::string ** err_msg, casadi::IM* obj)"
+// call: "        size_t ret = obj->element_hash();"
+// params: []
+extern "C"
+size_t
+    casadi__IM__element_hash(std::string ** err_msg, casadi::IM* obj);
+size_t
+    casadi__IM__element_hash(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        size_t ret = obj->element_hash();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::enlarge"
+// cWrapperName: "casadi__IM__enlarge__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__enlarge__0(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__enlarge__0(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+void
+    casadi__IM__enlarge__0(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        obj->enlarge(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::enlarge"
+// cWrapperName: "casadi__IM__enlarge__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__enlarge__1(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_, x4_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__enlarge__1(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
+void
+    casadi__IM__enlarge__1(std::string ** err_msg, casadi::IM* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::erase"
+// cWrapperName: "casadi__IM__erase__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__erase__0(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0)"
+// call: "        obj->erase(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__erase__0(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0);
+void
+    casadi__IM__erase__0(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        obj->erase(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::erase"
+// cWrapperName: "casadi__IM__erase__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__erase__1(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, int x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__erase__1(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, int x1);
+void
+    casadi__IM__erase__1(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, int x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::erase"
+// cWrapperName: "casadi__IM__erase__2"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__erase__2(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__erase__2(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1);
+void
+    casadi__IM__erase__2(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::erase"
+// cWrapperName: "casadi__IM__erase__3"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__erase__3(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// call: "        obj->erase(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__erase__3(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
+void
+    casadi__IM__erase__3(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->erase(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "eye" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::eye"
+// cWrapperName: "casadi__IM__eye"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__eye(std::string ** err_msg, int x0)"
+// call: "        casadi::IM ret = casadi::IM::eye(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__eye(std::string ** err_msg, int x0);
+casadi::IM*
+    casadi__IM__eye(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::eye(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get"
+// cWrapperName: "casadi__IM__get__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get__0(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get__0(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__IM__get__0(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get"
+// cWrapperName: "casadi__IM__get__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get__1(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get__1(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__IM__get__1(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get"
+// cWrapperName: "casadi__IM__get__2"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get__2(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get__2(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__IM__get__2(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get"
+// cWrapperName: "casadi__IM__get__3"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get__3(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get__3(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__IM__get__3(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get"
+// cWrapperName: "casadi__IM__get__4"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get__4(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get__4(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__IM__get__4(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get"
+// cWrapperName: "casadi__IM__get__5"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get__5(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get__5(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2);
+void
+    casadi__IM__get__5(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get"
+// cWrapperName: "casadi__IM__get__6"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get__6(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get__6(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2);
+void
+    casadi__IM__get__6(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "getEqualityCheckingDepth" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::getEqualityCheckingDepth"
+// cWrapperName: "casadi__IM__getEqualityCheckingDepth"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__getEqualityCheckingDepth(std::string ** err_msg)"
+// call: "        int ret = casadi::IM::getEqualityCheckingDepth();"
+// params: []
+extern "C"
+int
+    casadi__IM__getEqualityCheckingDepth(std::string ** err_msg);
+int
+    casadi__IM__getEqualityCheckingDepth(std::string ** err_msg){
+    try {
+
+        int ret = casadi::IM::getEqualityCheckingDepth();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_colind" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get_colind"
+// cWrapperName: "casadi__IM__get_colind"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__IM__get_colind(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::vector< int > ret = obj->get_colind();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__IM__get_colind(std::string ** err_msg, casadi::IM* obj);
+std::vector< int >*
+    casadi__IM__get_colind(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::vector< int > ret = obj->get_colind();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "get_input" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get_input"
+// cWrapperName: "casadi__IM__get_input"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "IM"))
+// cWrapperRetType: "std::vector< casadi::IM* >*"
+// proto: "std::vector< casadi::IM* >*\n    casadi__IM__get_input(std::string ** err_msg, casadi::Function* x0)"
+// call: "        std::vector< casadi::IM > ret = casadi::IM::get_input(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+std::vector< casadi::IM* >*
+    casadi__IM__get_input(std::string ** err_msg, casadi::Function* x0);
+std::vector< casadi::IM* >*
+    casadi__IM__get_input(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        std::vector< casadi::IM > ret = casadi::IM::get_input(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::IM* >*, std::vector< casadi::IM > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nonzeros" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get_nonzeros"
+// cWrapperName: "casadi__IM__get_nonzeros"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__IM__get_nonzeros(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::vector< int > ret = obj->get_nonzeros();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__IM__get_nonzeros(std::string ** err_msg, casadi::IM* obj);
+std::vector< int >*
+    casadi__IM__get_nonzeros(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::vector< int > ret = obj->get_nonzeros();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get_nz"
+// cWrapperName: "casadi__IM__get_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get_nz__0(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get_nz__0(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2);
+void
+    casadi__IM__get_nz__0(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get_nz"
+// cWrapperName: "casadi__IM__get_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__get_nz__1(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "IM")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__get_nz__1(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2);
+void
+    casadi__IM__get_nz__1(std::string ** err_msg, casadi::IM* obj, casadi::IM** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::IM x0_ = casadi::IM();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_row" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get_row"
+// cWrapperName: "casadi__IM__get_row"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__IM__get_row(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::vector< int > ret = obj->get_row();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__IM__get_row(std::string ** err_msg, casadi::IM* obj);
+std::vector< int >*
+    casadi__IM__get_row(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::vector< int > ret = obj->get_row();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_sparsity" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::get_sparsity"
+// cWrapperName: "casadi__IM__get_sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__IM__get_sparsity(std::string ** err_msg, casadi::IM* obj)"
+// call: "        casadi::Sparsity ret = obj->get_sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__IM__get_sparsity(std::string ** err_msg, casadi::IM* obj);
+casadi::Sparsity*
+    casadi__IM__get_sparsity(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        casadi::Sparsity ret = obj->get_sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::grad"
+// cWrapperName: "casadi__IM__grad__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::IM*
+    casadi__IM__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::grad"
+// cWrapperName: "casadi__IM__grad__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::IM*
+    casadi__IM__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::grad"
+// cWrapperName: "casadi__IM__grad__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::IM ret = casadi::IM::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::IM*
+    casadi__IM__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::grad"
+// cWrapperName: "casadi__IM__grad__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::IM*
+    casadi__IM__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::grad"
+// cWrapperName: "casadi__IM__grad__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__grad__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::IM ret = casadi::IM::grad(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__grad__4(std::string ** err_msg, casadi::Function* x0);
+casadi::IM*
+    casadi__IM__grad__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::grad(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::grad"
+// cWrapperName: "casadi__IM__grad__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__grad__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__grad__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::IM*
+    casadi__IM__grad__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::grad"
+// cWrapperName: "casadi__IM__grad__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::IM*
+    casadi__IM__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_duplicates" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::has_duplicates"
+// cWrapperName: "casadi__IM__has_duplicates"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__has_duplicates(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->has_duplicates();"
+// params: []
+extern "C"
+int
+    casadi__IM__has_duplicates(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__has_duplicates(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->has_duplicates();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_nz" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::has_nz"
+// cWrapperName: "casadi__IM__has_nz"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__has_nz(std::string ** err_msg, casadi::IM* obj, int x0, int x1)"
+// call: "        bool ret = obj->has_nz(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__IM__has_nz(std::string ** err_msg, casadi::IM* obj, int x0, int x1);
+int
+    casadi__IM__has_nz(std::string ** err_msg, casadi::IM* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        bool ret = obj->has_nz(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_zeros" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::has_zeros"
+// cWrapperName: "casadi__IM__has_zeros"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__has_zeros(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->has_zeros();"
+// params: []
+extern "C"
+int
+    casadi__IM__has_zeros(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__has_zeros(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->has_zeros();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::hess"
+// cWrapperName: "casadi__IM__hess__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::IM*
+    casadi__IM__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::hess"
+// cWrapperName: "casadi__IM__hess__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::IM*
+    casadi__IM__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::hess"
+// cWrapperName: "casadi__IM__hess__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::IM ret = casadi::IM::hess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::IM*
+    casadi__IM__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::hess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::hess"
+// cWrapperName: "casadi__IM__hess__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::IM*
+    casadi__IM__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::hess"
+// cWrapperName: "casadi__IM__hess__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__hess__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::IM ret = casadi::IM::hess(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__hess__4(std::string ** err_msg, casadi::Function* x0);
+casadi::IM*
+    casadi__IM__hess__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::hess(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::hess"
+// cWrapperName: "casadi__IM__hess__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__hess__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::hess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__hess__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::IM*
+    casadi__IM__hess__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::hess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::hess"
+// cWrapperName: "casadi__IM__hess__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::IM*
+    casadi__IM__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::inf"
+// cWrapperName: "casadi__IM__inf__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::IM ret = casadi::IM::inf(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::IM*
+    casadi__IM__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::inf"
+// cWrapperName: "casadi__IM__inf__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__inf__1(std::string ** err_msg)"
+// call: "        casadi::IM ret = casadi::IM::inf();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__inf__1(std::string ** err_msg);
+casadi::IM*
+    casadi__IM__inf__1(std::string ** err_msg){
+    try {
+
+        casadi::IM ret = casadi::IM::inf();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::inf"
+// cWrapperName: "casadi__IM__inf__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__inf__2(std::string ** err_msg, int x0)"
+// call: "        casadi::IM ret = casadi::IM::inf(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__inf__2(std::string ** err_msg, int x0);
+casadi::IM*
+    casadi__IM__inf__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::inf"
+// cWrapperName: "casadi__IM__inf__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__inf__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::inf(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__inf__3(std::string ** err_msg, int x0, int x1);
+casadi::IM*
+    casadi__IM__inf__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::inf(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::inf"
+// cWrapperName: "casadi__IM__inf__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::IM ret = casadi::IM::inf(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::IM*
+    casadi__IM__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_column" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_column"
+// cWrapperName: "casadi__IM__is_column"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_column(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_column();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_column(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_column(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_column();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_commutative" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_commutative"
+// cWrapperName: "casadi__IM__is_commutative"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_commutative(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_commutative();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_commutative(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_commutative(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_commutative();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_constant" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_constant"
+// cWrapperName: "casadi__IM__is_constant"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_constant(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_constant();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_constant(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_constant(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_constant();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_dense" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_dense"
+// cWrapperName: "casadi__IM__is_dense"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_dense(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_dense();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_dense(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_dense(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_dense();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_empty"
+// cWrapperName: "casadi__IM__is_empty__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_empty__0(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_empty();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_empty__0(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_empty__0(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_empty();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_empty"
+// cWrapperName: "casadi__IM__is_empty__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_empty__1(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        bool ret = obj->is_empty(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__IM__is_empty__1(std::string ** err_msg, casadi::IM* obj, int x0);
+int
+    casadi__IM__is_empty__1(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_empty(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_identity" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_identity"
+// cWrapperName: "casadi__IM__is_identity"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_identity(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_identity();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_identity(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_identity(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_identity();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_integer" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_integer"
+// cWrapperName: "casadi__IM__is_integer"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_integer(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_integer();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_integer(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_integer(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_integer();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_leaf" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_leaf"
+// cWrapperName: "casadi__IM__is_leaf"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_leaf(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_leaf();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_leaf(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_leaf(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_leaf();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_minus_one" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_minus_one"
+// cWrapperName: "casadi__IM__is_minus_one"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_minus_one(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_minus_one();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_minus_one(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_minus_one(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_minus_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_one" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_one"
+// cWrapperName: "casadi__IM__is_one"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_one(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_one();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_one(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_one(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_regular" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_regular"
+// cWrapperName: "casadi__IM__is_regular"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_regular(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_regular();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_regular(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_regular(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_regular();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_row" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_row"
+// cWrapperName: "casadi__IM__is_row"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_row(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_row();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_row(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_row(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_row();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_scalar"
+// cWrapperName: "casadi__IM__is_scalar__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_scalar__0(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_scalar();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_scalar__0(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_scalar__0(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_scalar();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_scalar"
+// cWrapperName: "casadi__IM__is_scalar__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_scalar__1(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        bool ret = obj->is_scalar(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__IM__is_scalar__1(std::string ** err_msg, casadi::IM* obj, int x0);
+int
+    casadi__IM__is_scalar__1(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_smooth" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_smooth"
+// cWrapperName: "casadi__IM__is_smooth"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_smooth(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_smooth();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_smooth(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_smooth(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_smooth();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_square" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_square"
+// cWrapperName: "casadi__IM__is_square"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_square(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_square();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_square(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_square(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_square();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_symbolic" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_symbolic"
+// cWrapperName: "casadi__IM__is_symbolic"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_symbolic(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_symbolic();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_symbolic(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_symbolic(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_symbolic();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_tril" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_tril"
+// cWrapperName: "casadi__IM__is_tril"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_tril(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_tril();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_tril(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_tril(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_tril();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_triu" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_triu"
+// cWrapperName: "casadi__IM__is_triu"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_triu(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_triu();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_triu(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_triu(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_triu();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_valid_input" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_valid_input"
+// cWrapperName: "casadi__IM__is_valid_input"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_valid_input(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_valid_input();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_valid_input(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_valid_input(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_valid_input();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_vector" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_vector"
+// cWrapperName: "casadi__IM__is_vector"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_vector(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_vector();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_vector(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_vector(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_zero" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::is_zero"
+// cWrapperName: "casadi__IM__is_zero"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__is_zero(std::string ** err_msg, casadi::IM* obj)"
+// call: "        bool ret = obj->is_zero();"
+// params: []
+extern "C"
+int
+    casadi__IM__is_zero(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__is_zero(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        bool ret = obj->is_zero();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::IM*
+    casadi__IM__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3);
+casadi::IM*
+    casadi__IM__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4);
+casadi::IM*
+    casadi__IM__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::IM*
+    casadi__IM__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3);
+casadi::IM*
+    casadi__IM__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4);
+casadi::IM*
+    casadi__IM__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::IM*
+    casadi__IM__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::IM*
+    casadi__IM__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3);
+casadi::IM*
+    casadi__IM__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4);
+casadi::IM*
+    casadi__IM__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__10"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__10(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__10(std::string ** err_msg, casadi::Function* x0);
+casadi::IM*
+    casadi__IM__jac__10(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::jac(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__11"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__11(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__11(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::IM*
+    casadi__IM__jac__11(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__12"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::IM*
+    casadi__IM__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__13"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3);
+casadi::IM*
+    casadi__IM__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::jac"
+// cWrapperName: "casadi__IM__jac__14"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// call: "        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4);
+casadi::IM*
+    casadi__IM__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::IM ret = casadi::IM::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "matrix_matrix" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::matrix_matrix"
+// cWrapperName: "casadi__IM__matrix_matrix"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__matrix_matrix(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// call: "        casadi::IM ret = casadi::IM::matrix_matrix(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__matrix_matrix(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2);
+casadi::IM*
+    casadi__IM__matrix_matrix(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::IM& x1_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::matrix_matrix(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "matrix_scalar" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::matrix_scalar"
+// cWrapperName: "casadi__IM__matrix_scalar"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__matrix_scalar(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// call: "        casadi::IM ret = casadi::IM::matrix_scalar(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__matrix_scalar(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2);
+casadi::IM*
+    casadi__IM__matrix_scalar(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::IM& x1_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::matrix_scalar(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_dep" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::n_dep"
+// cWrapperName: "casadi__IM__n_dep"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__n_dep(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->n_dep();"
+// params: []
+extern "C"
+int
+    casadi__IM__n_dep(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__n_dep(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->n_dep();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::name"
+// cWrapperName: "casadi__IM__name"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__IM__name(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::string ret = obj->name();"
+// params: []
+extern "C"
+std::string*
+    casadi__IM__name(std::string ** err_msg, casadi::IM* obj);
+std::string*
+    casadi__IM__name(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::string ret = obj->name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nan"
+// cWrapperName: "casadi__IM__nan__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::IM ret = casadi::IM::nan(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::IM*
+    casadi__IM__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nan"
+// cWrapperName: "casadi__IM__nan__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__nan__1(std::string ** err_msg)"
+// call: "        casadi::IM ret = casadi::IM::nan();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__nan__1(std::string ** err_msg);
+casadi::IM*
+    casadi__IM__nan__1(std::string ** err_msg){
+    try {
+
+        casadi::IM ret = casadi::IM::nan();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nan"
+// cWrapperName: "casadi__IM__nan__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__nan__2(std::string ** err_msg, int x0)"
+// call: "        casadi::IM ret = casadi::IM::nan(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__nan__2(std::string ** err_msg, int x0);
+casadi::IM*
+    casadi__IM__nan__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nan"
+// cWrapperName: "casadi__IM__nan__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__nan__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::nan(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__nan__3(std::string ** err_msg, int x0, int x1);
+casadi::IM*
+    casadi__IM__nan__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::nan(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nan"
+// cWrapperName: "casadi__IM__nan__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::IM ret = casadi::IM::nan(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::IM*
+    casadi__IM__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nnz"
+// cWrapperName: "casadi__IM__nnz"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__nnz(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->nnz();"
+// params: []
+extern "C"
+int
+    casadi__IM__nnz(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__nnz(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->nnz();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_diag" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nnz_diag"
+// cWrapperName: "casadi__IM__nnz_diag"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__nnz_diag(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->nnz_diag();"
+// params: []
+extern "C"
+int
+    casadi__IM__nnz_diag(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__nnz_diag(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->nnz_diag();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_lower" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nnz_lower"
+// cWrapperName: "casadi__IM__nnz_lower"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__nnz_lower(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->nnz_lower();"
+// params: []
+extern "C"
+int
+    casadi__IM__nnz_lower(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__nnz_lower(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->nnz_lower();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_upper" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::nnz_upper"
+// cWrapperName: "casadi__IM__nnz_upper"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__nnz_upper(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->nnz_upper();"
+// params: []
+extern "C"
+int
+    casadi__IM__nnz_upper(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__nnz_upper(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->nnz_upper();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::numel"
+// cWrapperName: "casadi__IM__numel__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__numel__0(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        int ret = obj->numel(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__IM__numel__0(std::string ** err_msg, casadi::IM* obj, int x0);
+int
+    casadi__IM__numel__0(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->numel(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::numel"
+// cWrapperName: "casadi__IM__numel__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__numel__1(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->numel();"
+// params: []
+extern "C"
+int
+    casadi__IM__numel__1(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__numel__1(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->numel();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::ones"
+// cWrapperName: "casadi__IM__ones__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::IM ret = casadi::IM::ones(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::IM*
+    casadi__IM__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::ones"
+// cWrapperName: "casadi__IM__ones__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::IM ret = casadi::IM::ones(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::IM*
+    casadi__IM__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::ones"
+// cWrapperName: "casadi__IM__ones__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__ones__2(std::string ** err_msg)"
+// call: "        casadi::IM ret = casadi::IM::ones();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__ones__2(std::string ** err_msg);
+casadi::IM*
+    casadi__IM__ones__2(std::string ** err_msg){
+    try {
+
+        casadi::IM ret = casadi::IM::ones();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::ones"
+// cWrapperName: "casadi__IM__ones__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__ones__3(std::string ** err_msg, int x0)"
+// call: "        casadi::IM ret = casadi::IM::ones(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__ones__3(std::string ** err_msg, int x0);
+casadi::IM*
+    casadi__IM__ones__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::ones"
+// cWrapperName: "casadi__IM__ones__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__ones__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::ones(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__ones__4(std::string ** err_msg, int x0, int x1);
+casadi::IM*
+    casadi__IM__ones__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::ones(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator +" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::operator +"
+// cWrapperName: "casadi__IM__operator__plus"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__operator__plus(std::string ** err_msg, casadi::IM* obj)"
+// call: "        casadi::IM ret = obj->operator +();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__operator__plus(std::string ** err_msg, casadi::IM* obj);
+casadi::IM*
+    casadi__IM__operator__plus(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        casadi::IM ret = obj->operator +();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator -" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::operator -"
+// cWrapperName: "casadi__IM__operator__minus"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__operator__minus(std::string ** err_msg, casadi::IM* obj)"
+// call: "        casadi::IM ret = obj->operator -();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__operator__minus(std::string ** err_msg, casadi::IM* obj);
+casadi::IM*
+    casadi__IM__operator__minus(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        casadi::IM ret = obj->operator -();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator double" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::operator double"
+// cWrapperName: "casadi__IM__operator_double"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__IM__operator_double(std::string ** err_msg, casadi::IM* obj)"
+// call: "        double ret = obj->operator double();"
+// params: []
+extern "C"
+double
+    casadi__IM__operator_double(std::string ** err_msg, casadi::IM* obj);
+double
+    casadi__IM__operator_double(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        double ret = obj->operator double();
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator int" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::operator int"
+// cWrapperName: "casadi__IM__operator_int"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__operator_int(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->operator int();"
+// params: []
+extern "C"
+int
+    casadi__IM__operator_int(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__operator_int(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->operator int();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "print_dense" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::print_dense"
+// cWrapperName: "casadi__IM__print_dense"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__print_dense(std::string ** err_msg, casadi::IM* obj)"
+// call: "        obj->print_dense();"
+// params: []
+extern "C"
+void
+    casadi__IM__print_dense(std::string ** err_msg, casadi::IM* obj);
+void
+    casadi__IM__print_dense(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        obj->print_dense();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_scalar" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::print_scalar"
+// cWrapperName: "casadi__IM__print_scalar"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__print_scalar(std::string ** err_msg, casadi::IM* obj)"
+// call: "        obj->print_scalar();"
+// params: []
+extern "C"
+void
+    casadi__IM__print_scalar(std::string ** err_msg, casadi::IM* obj);
+void
+    casadi__IM__print_scalar(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        obj->print_scalar();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_sparse" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::print_sparse"
+// cWrapperName: "casadi__IM__print_sparse"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__print_sparse(std::string ** err_msg, casadi::IM* obj)"
+// call: "        obj->print_sparse();"
+// params: []
+extern "C"
+void
+    casadi__IM__print_sparse(std::string ** err_msg, casadi::IM* obj);
+void
+    casadi__IM__print_sparse(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        obj->print_sparse();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_split" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::print_split"
+// cWrapperName: "casadi__IM__print_split"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__print_split(std::string ** err_msg, casadi::IM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1)"
+// call: "        obj->print_split(x0_, x1_);"
+// params: [(Ref (StdVec StdString),SwigOutput True),(Ref (StdVec StdString),SwigOutput True)]
+extern "C"
+void
+    casadi__IM__print_split(std::string ** err_msg, casadi::IM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1);
+void
+    casadi__IM__print_split(std::string ** err_msg, casadi::IM* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1){
+    try {
+        std::vector< std::string > x0_ = std::vector< std::string >();  // Swig output
+        std::vector< std::string > x1_ = std::vector< std::string >();  // Swig output
+
+        obj->print_split(x0_, x1_);
+        *x0 = WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_vector" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::print_vector"
+// cWrapperName: "casadi__IM__print_vector"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__print_vector(std::string ** err_msg, casadi::IM* obj)"
+// call: "        obj->print_vector();"
+// params: []
+extern "C"
+void
+    casadi__IM__print_vector(std::string ** err_msg, casadi::IM* obj);
+void
+    casadi__IM__print_vector(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        obj->print_vector();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "printme" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::printme"
+// cWrapperName: "casadi__IM__printme"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__printme(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0)"
+// call: "        casadi::IM ret = obj->printme(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__printme(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0);
+casadi::IM*
+    casadi__IM__printme(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+
+        casadi::IM ret = obj->printme(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "remove" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::remove"
+// cWrapperName: "casadi__IM__remove"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__remove(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        obj->remove(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__remove(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1);
+void
+    casadi__IM__remove(std::string ** err_msg, casadi::IM* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->remove(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reserve" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::reserve"
+// cWrapperName: "casadi__IM__reserve__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__reserve__0(std::string ** err_msg, casadi::IM* obj, int x0, int x1)"
+// call: "        obj->reserve(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__reserve__0(std::string ** err_msg, casadi::IM* obj, int x0, int x1);
+void
+    casadi__IM__reserve__0(std::string ** err_msg, casadi::IM* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->reserve(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reserve" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::reserve"
+// cWrapperName: "casadi__IM__reserve__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__reserve__1(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        obj->reserve(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__reserve__1(std::string ** err_msg, casadi::IM* obj, int x0);
+void
+    casadi__IM__reserve__1(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        obj->reserve(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "resetInput" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::resetInput"
+// cWrapperName: "casadi__IM__resetInput"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__resetInput(std::string ** err_msg, casadi::IM* obj)"
+// call: "        obj->resetInput();"
+// params: []
+extern "C"
+void
+    casadi__IM__resetInput(std::string ** err_msg, casadi::IM* obj);
+void
+    casadi__IM__resetInput(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        obj->resetInput();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "resize" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::resize"
+// cWrapperName: "casadi__IM__resize"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__resize(std::string ** err_msg, casadi::IM* obj, int x0, int x1)"
+// call: "        obj->resize(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__resize(std::string ** err_msg, casadi::IM* obj, int x0, int x1);
+void
+    casadi__IM__resize(std::string ** err_msg, casadi::IM* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->resize(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "row" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::row"
+// cWrapperName: "casadi__IM__row"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__row(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        int ret = obj->row(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__IM__row(std::string ** err_msg, casadi::IM* obj, int x0);
+int
+    casadi__IM__row(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->row(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sanity_check"
+// cWrapperName: "casadi__IM__sanity_check__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__sanity_check__0(std::string ** err_msg, casadi::IM* obj)"
+// call: "        obj->sanity_check();"
+// params: []
+extern "C"
+void
+    casadi__IM__sanity_check__0(std::string ** err_msg, casadi::IM* obj);
+void
+    casadi__IM__sanity_check__0(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        obj->sanity_check();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sanity_check"
+// cWrapperName: "casadi__IM__sanity_check__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__sanity_check__1(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        obj->sanity_check(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__sanity_check__1(std::string ** err_msg, casadi::IM* obj, int x0);
+void
+    casadi__IM__sanity_check__1(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        obj->sanity_check(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "scalar_matrix" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::scalar_matrix"
+// cWrapperName: "casadi__IM__scalar_matrix"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__scalar_matrix(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2)"
+// call: "        casadi::IM ret = casadi::IM::scalar_matrix(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__scalar_matrix(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2);
+casadi::IM*
+    casadi__IM__scalar_matrix(std::string ** err_msg, int x0, casadi::IM* x1, casadi::IM* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::IM& x1_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::scalar_matrix(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set"
+// cWrapperName: "casadi__IM__set__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set__0(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set__0(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__IM__set__0(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set"
+// cWrapperName: "casadi__IM__set__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set__1(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set__1(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__IM__set__1(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set"
+// cWrapperName: "casadi__IM__set__2"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set__2(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set__2(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__IM__set__2(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set"
+// cWrapperName: "casadi__IM__set__3"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set__3(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set__3(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__IM__set__3(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set"
+// cWrapperName: "casadi__IM__set__4"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set__4(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set__4(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__IM__set__4(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set"
+// cWrapperName: "casadi__IM__set__5"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set__5(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set__5(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2);
+void
+    casadi__IM__set__5(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set"
+// cWrapperName: "casadi__IM__set__6"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set__6(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set__6(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2);
+void
+    casadi__IM__set__6(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::setEqualityCheckingDepth"
+// cWrapperName: "casadi__IM__setEqualityCheckingDepth__0"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__setEqualityCheckingDepth__0(std::string ** err_msg)"
+// call: "        casadi::IM::setEqualityCheckingDepth();"
+// params: []
+extern "C"
+void
+    casadi__IM__setEqualityCheckingDepth__0(std::string ** err_msg);
+void
+    casadi__IM__setEqualityCheckingDepth__0(std::string ** err_msg){
+    try {
+
+        casadi::IM::setEqualityCheckingDepth();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::setEqualityCheckingDepth"
+// cWrapperName: "casadi__IM__setEqualityCheckingDepth__1"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
+// call: "        casadi::IM::setEqualityCheckingDepth(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
+void
+    casadi__IM__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM::setEqualityCheckingDepth(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setPrecision" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::setPrecision"
+// cWrapperName: "casadi__IM__setPrecision"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__setPrecision(std::string ** err_msg, int x0)"
+// call: "        casadi::IM::setPrecision(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__setPrecision(std::string ** err_msg, int x0);
+void
+    casadi__IM__setPrecision(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM::setPrecision(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setScientific" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::setScientific"
+// cWrapperName: "casadi__IM__setScientific"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__setScientific(std::string ** err_msg, int x0)"
+// call: "        casadi::IM::setScientific(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__setScientific(std::string ** err_msg, int x0);
+void
+    casadi__IM__setScientific(std::string ** err_msg, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::IM::setScientific(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setWidth" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::setWidth"
+// cWrapperName: "casadi__IM__setWidth"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__setWidth(std::string ** err_msg, int x0)"
+// call: "        casadi::IM::setWidth(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__IM__setWidth(std::string ** err_msg, int x0);
+void
+    casadi__IM__setWidth(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM::setWidth(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set_nz"
+// cWrapperName: "casadi__IM__set_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set_nz__0(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set_nz__0(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2);
+void
+    casadi__IM__set_nz__0(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::set_nz"
+// cWrapperName: "casadi__IM__set_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__IM__set_nz__1(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__IM__set_nz__1(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2);
+void
+    casadi__IM__set_nz__1(std::string ** err_msg, casadi::IM* obj, casadi::IM* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::size"
+// cWrapperName: "casadi__IM__size__0"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__size__0(std::string ** err_msg, casadi::IM* obj, int x0)"
+// call: "        int ret = obj->size(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__IM__size__0(std::string ** err_msg, casadi::IM* obj, int x0);
+int
+    casadi__IM__size__0(std::string ** err_msg, casadi::IM* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::size"
+// cWrapperName: "casadi__IM__size__1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__IM__size__1(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::pair< int, int > ret = obj->size();"
+// params: []
+extern "C"
+std::pair< int, int >*
+    casadi__IM__size__1(std::string ** err_msg, casadi::IM* obj);
+std::pair< int, int >*
+    casadi__IM__size__1(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::pair< int, int > ret = obj->size();
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::size1"
+// cWrapperName: "casadi__IM__size1"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__size1(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->size1();"
+// params: []
+extern "C"
+int
+    casadi__IM__size1(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__size1(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->size1();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::size2"
+// cWrapperName: "casadi__IM__size2"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__IM__size2(std::string ** err_msg, casadi::IM* obj)"
+// call: "        int ret = obj->size2();"
+// params: []
+extern "C"
+int
+    casadi__IM__size2(std::string ** err_msg, casadi::IM* obj);
+int
+    casadi__IM__size2(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        int ret = obj->size2();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sparsity"
+// cWrapperName: "casadi__IM__sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__IM__sparsity(std::string ** err_msg, casadi::IM* obj)"
+// call: "        casadi::Sparsity ret = obj->sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__IM__sparsity(std::string ** err_msg, casadi::IM* obj);
+casadi::Sparsity*
+    casadi__IM__sparsity(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        casadi::Sparsity ret = obj->sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IM")))
+// cWrapperRetType: "std::vector< std::vector< casadi::IM* >* >*"
+// proto: "std::vector< std::vector< casadi::IM* >* >*\n    casadi__IM__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// call: "        std::vector< std::vector< casadi::IM > > ret = casadi::IM::sym(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::IM* >* >*
+    casadi__IM__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
+std::vector< std::vector< casadi::IM* >* >*
+    casadi__IM__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        int x4_ = Marshaling<int,int>::marshal(x4);
+
+        std::vector< std::vector< casadi::IM > > ret = casadi::IM::sym(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::IM* >* >*, std::vector< std::vector< casadi::IM > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IM")))
+// cWrapperRetType: "std::vector< std::vector< casadi::IM* >* >*"
+// proto: "std::vector< std::vector< casadi::IM* >* >*\n    casadi__IM__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// call: "        std::vector< std::vector< casadi::IM > > ret = casadi::IM::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::IM* >* >*
+    casadi__IM__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
+std::vector< std::vector< casadi::IM* >* >*
+    casadi__IM__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< std::vector< casadi::IM > > ret = casadi::IM::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::IM* >* >*, std::vector< std::vector< casadi::IM > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__2"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "IM"))
+// cWrapperRetType: "std::vector< casadi::IM* >*"
+// proto: "std::vector< casadi::IM* >*\n    casadi__IM__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// call: "        std::vector< casadi::IM > ret = casadi::IM::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::IM* >*
+    casadi__IM__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
+std::vector< casadi::IM* >*
+    casadi__IM__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< casadi::IM > ret = casadi::IM::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< casadi::IM* >*, std::vector< casadi::IM > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__3"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "IM"))
+// cWrapperRetType: "std::vector< casadi::IM* >*"
+// proto: "std::vector< casadi::IM* >*\n    casadi__IM__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// call: "        std::vector< casadi::IM > ret = casadi::IM::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::IM* >*
+    casadi__IM__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
+std::vector< casadi::IM* >*
+    casadi__IM__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        std::vector< casadi::IM > ret = casadi::IM::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< std::vector< casadi::IM* >*, std::vector< casadi::IM > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__4"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// call: "        casadi::IM ret = casadi::IM::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
+casadi::IM*
+    casadi__IM__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__5"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// call: "        casadi::IM ret = casadi::IM::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
+casadi::IM*
+    casadi__IM__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__6"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__sym__6(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::IM ret = casadi::IM::sym(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__sym__6(std::string ** err_msg, std::string* x0);
+casadi::IM*
+    casadi__IM__sym__6(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::sym(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__7"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__sym__7(std::string ** err_msg, std::string* x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__sym__7(std::string ** err_msg, std::string* x0, int x1);
+casadi::IM*
+    casadi__IM__sym__7(std::string ** err_msg, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::sym"
+// cWrapperName: "casadi__IM__sym__8"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
+casadi::IM*
+    casadi__IM__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::tang"
+// cWrapperName: "casadi__IM__tang__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::IM*
+    casadi__IM__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::tang"
+// cWrapperName: "casadi__IM__tang__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::IM*
+    casadi__IM__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::tang"
+// cWrapperName: "casadi__IM__tang__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::IM ret = casadi::IM::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::IM*
+    casadi__IM__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::tang"
+// cWrapperName: "casadi__IM__tang__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::IM*
+    casadi__IM__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::tang"
+// cWrapperName: "casadi__IM__tang__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__tang__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::IM ret = casadi::IM::tang(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__tang__4(std::string ** err_msg, casadi::Function* x0);
+casadi::IM*
+    casadi__IM__tang__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::tang(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::tang"
+// cWrapperName: "casadi__IM__tang__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__tang__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__tang__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::IM*
+    casadi__IM__tang__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::tang"
+// cWrapperName: "casadi__IM__tang__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::IM*
+    casadi__IM__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::triplet"
+// cWrapperName: "casadi__IM__triplet__0"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, std::pair< int, int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, std::pair< int, int >* x3)"
+// call: "        casadi::IM ret = casadi::IM::triplet(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, std::pair< int, int >* x3);
+casadi::IM*
+    casadi__IM__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, std::pair< int, int >* x3){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        std::pair< int, int > x3_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x3);
+
+        casadi::IM ret = casadi::IM::triplet(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::triplet"
+// cWrapperName: "casadi__IM__triplet__1"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, int x3, int x4)"
+// call: "        casadi::IM ret = casadi::IM::triplet(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, int x3, int x4);
+casadi::IM*
+    casadi__IM__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2, int x3, int x4){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        int x4_ = Marshaling<int,int>::marshal(x4);
+
+        casadi::IM ret = casadi::IM::triplet(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::triplet"
+// cWrapperName: "casadi__IM__triplet__2"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2)"
+// call: "        casadi::IM ret = casadi::IM::triplet(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2);
+casadi::IM*
+    casadi__IM__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::IM* x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        casadi::IM ret = casadi::IM::triplet(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "type_name" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::type_name"
+// cWrapperName: "casadi__IM__type_name"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__IM__type_name(std::string ** err_msg)"
+// call: "        std::string ret = casadi::IM::type_name();"
+// params: []
+extern "C"
+std::string*
+    casadi__IM__type_name(std::string ** err_msg);
+std::string*
+    casadi__IM__type_name(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::IM::type_name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "unary" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::unary"
+// cWrapperName: "casadi__IM__unary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::IM* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__unary(std::string ** err_msg, int x0, casadi::IM* x1)"
+// call: "        casadi::IM ret = casadi::IM::unary(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__unary(std::string ** err_msg, int x0, casadi::IM* x1);
+casadi::IM*
+    casadi__IM__unary(std::string ** err_msg, int x0, casadi::IM* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::IM& x1_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::unary(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::zeros"
+// cWrapperName: "casadi__IM__zeros__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::IM ret = casadi::IM::zeros(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::IM*
+    casadi__IM__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::zeros"
+// cWrapperName: "casadi__IM__zeros__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::IM ret = casadi::IM::zeros(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::IM*
+    casadi__IM__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::zeros"
+// cWrapperName: "casadi__IM__zeros__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__zeros__2(std::string ** err_msg)"
+// call: "        casadi::IM ret = casadi::IM::zeros();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__IM__zeros__2(std::string ** err_msg);
+casadi::IM*
+    casadi__IM__zeros__2(std::string ** err_msg){
+    try {
+
+        casadi::IM ret = casadi::IM::zeros();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::zeros"
+// cWrapperName: "casadi__IM__zeros__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__zeros__3(std::string ** err_msg, int x0)"
+// call: "        casadi::IM ret = casadi::IM::zeros(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__zeros__3(std::string ** err_msg, int x0);
+casadi::IM*
+    casadi__IM__zeros__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::IM ret = casadi::IM::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::zeros"
+// cWrapperName: "casadi__IM__zeros__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__IM__zeros__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::IM ret = casadi::IM::zeros(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::IM*
+    casadi__IM__zeros__4(std::string ** err_msg, int x0, int x1);
+casadi::IM*
+    casadi__IM__zeros__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::IM ret = casadi::IM::zeros(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::getRepresentation"
+// cWrapperName: "casadi__IM__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__IM__getRepresentation(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__IM__getRepresentation(std::string ** err_msg, casadi::IM* obj);
+std::string*
+    casadi__IM__getRepresentation(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::IM"
+// cppName: "casadi::IM::getDescription"
+// cWrapperName: "casadi__IM__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::IM* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__IM__getDescription(std::string ** err_msg, casadi::IM* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__IM__getDescription(std::string ** err_msg, casadi::IM* obj);
+std::string*
+    casadi__IM__getDescription(std::string ** err_msg, casadi::IM* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "Library")===============
+// classType: UserType (Namespace ["casadi"]) (Name "Library")
+extern "C"
+void delete_casadi__Library(casadi::Library* obj);
+void delete_casadi__Library(casadi::Library* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Library"
+// cppName: "casadi::Library"
+// cWrapperName: "casadi__Library__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, casadi::Compiler* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Library")
+// cWrapperRetType: "casadi::Library*"
+// proto: "casadi::Library*\n    casadi__Library__CONSTRUCTOR__0(std::string ** err_msg, casadi::Compiler* x0)"
+// call: "        casadi::Library* ret = (casadi::Library*)new casadi::Library(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Compiler"))),SwigOutput False)]
+extern "C"
+casadi::Library*
+    casadi__Library__CONSTRUCTOR__0(std::string ** err_msg, casadi::Compiler* x0);
+casadi::Library*
+    casadi__Library__CONSTRUCTOR__0(std::string ** err_msg, casadi::Compiler* x0){
+    try {
+        casadi::Compiler& x0_ = Marshaling<casadi::Compiler&,casadi::Compiler*>::marshal(x0);
+
+        casadi::Library* ret = (casadi::Library*)new casadi::Library(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Library"
+// cppName: "casadi::Library"
+// cWrapperName: "casadi__Library__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Library")
+// cWrapperRetType: "casadi::Library*"
+// proto: "casadi::Library*\n    casadi__Library__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::Library* ret = (casadi::Library*)new casadi::Library(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Library*
+    casadi__Library__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0);
+casadi::Library*
+    casadi__Library__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Library* ret = (casadi::Library*)new casadi::Library(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Library"
+// cppName: "casadi::Library"
+// cWrapperName: "casadi__Library__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Library")
+// cWrapperRetType: "casadi::Library*"
+// proto: "casadi::Library*\n    casadi__Library__CONSTRUCTOR__2(std::string ** err_msg)"
+// call: "        casadi::Library* ret = (casadi::Library*)new casadi::Library();"
+// params: []
+extern "C"
+casadi::Library*
+    casadi__Library__CONSTRUCTOR__2(std::string ** err_msg);
+casadi::Library*
+    casadi__Library__CONSTRUCTOR__2(std::string ** err_msg){
+    try {
+
+        casadi::Library* ret = (casadi::Library*)new casadi::Library();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has" ===============
+// class: "casadi::Library"
+// cppName: "casadi::Library::has"
+// cWrapperName: "casadi__Library__has"
+// protoArgs: "(std::string ** err_msg, casadi::Library* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Library__has(std::string ** err_msg, casadi::Library* obj, std::string* x0)"
+// call: "        bool ret = obj->has(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+int
+    casadi__Library__has(std::string ** err_msg, casadi::Library* obj, std::string* x0);
+int
+    casadi__Library__has(std::string ** err_msg, casadi::Library* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        bool ret = obj->has(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "MX")===============
+// classType: UserType (Namespace ["casadi"]) (Name "MX")
+extern "C"
+void delete_casadi__MX(casadi::MX* obj);
+void delete_casadi__MX(casadi::MX* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, casadi::DM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DM* x0)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DM* x0);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DM* x0){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);"
+// params: [(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0){
+    try {
+        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, double x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);"
+// params: [(CDouble,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0){
+    try {
+        double x0_ = Marshaling<double,double>::marshal(x0);
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__5"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__6"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX"
+// cWrapperName: "casadi__MX__CONSTRUCTOR__7"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__CONSTRUCTOR__7(std::string ** err_msg)"
+// call: "        casadi::MX* ret = (casadi::MX*)new casadi::MX();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__7(std::string ** err_msg);
+casadi::MX*
+    casadi__MX__CONSTRUCTOR__7(std::string ** err_msg){
+    try {
+
+        casadi::MX* ret = (casadi::MX*)new casadi::MX();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "T" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::T"
+// cWrapperName: "casadi__MX__T"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__T(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::MX ret = obj->T();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__T(std::string ** err_msg, casadi::MX* obj);
+casadi::MX*
+    casadi__MX__T(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::MX ret = obj->T();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "__nonzero__" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::__nonzero__"
+// cWrapperName: "casadi__MX____nonzero__"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->__nonzero__();"
+// params: []
+extern "C"
+int
+    casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->__nonzero__();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "attachAssert" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::attachAssert"
+// cWrapperName: "casadi__MX__attachAssert__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
+// call: "        casadi::MX ret = obj->attachAssert(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
+casadi::MX*
+    casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        casadi::MX ret = obj->attachAssert(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "attachAssert" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::attachAssert"
+// cWrapperName: "casadi__MX__attachAssert__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1)"
+// call: "        casadi::MX ret = obj->attachAssert(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1);
+casadi::MX*
+    casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::MX ret = obj->attachAssert(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "binary" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::binary"
+// cWrapperName: "casadi__MX__binary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2)"
+// call: "        casadi::MX ret = casadi::MX::binary(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2);
+casadi::MX*
+    casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
+        casadi::MX& x2_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::binary(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "colind" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::colind"
+// cWrapperName: "casadi__MX__colind"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__colind(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        int ret = obj->colind(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__MX__colind(std::string ** err_msg, casadi::MX* obj, int x0);
+int
+    casadi__MX__colind(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->colind(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::dep"
+// cWrapperName: "casadi__MX__dep__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__dep__0(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::MX ret = obj->dep();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__dep__0(std::string ** err_msg, casadi::MX* obj);
+casadi::MX*
+    casadi__MX__dep__0(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::MX ret = obj->dep();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::dep"
+// cWrapperName: "casadi__MX__dep__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__dep__1(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        casadi::MX ret = obj->dep(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__dep__1(std::string ** err_msg, casadi::MX* obj, int x0);
+casadi::MX*
+    casadi__MX__dep__1(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = obj->dep(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dim" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::dim"
+// cWrapperName: "casadi__MX__dim"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__MX__dim(std::string ** err_msg, casadi::MX* obj)"
+// call: "        std::string ret = obj->dim();"
+// params: []
+extern "C"
+std::string*
+    casadi__MX__dim(std::string ** err_msg, casadi::MX* obj);
+std::string*
+    casadi__MX__dim(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        std::string ret = obj->dim();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::enlarge"
+// cWrapperName: "casadi__MX__enlarge__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__enlarge__0(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__enlarge__0(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+void
+    casadi__MX__enlarge__0(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        obj->enlarge(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::enlarge"
+// cWrapperName: "casadi__MX__enlarge__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__enlarge__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_, x4_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__MX__enlarge__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
+void
+    casadi__MX__enlarge__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::erase"
+// cWrapperName: "casadi__MX__erase__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__erase__0(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0)"
+// call: "        obj->erase(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__erase__0(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0);
+void
+    casadi__MX__erase__0(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        obj->erase(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::erase"
+// cWrapperName: "casadi__MX__erase__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__erase__1(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__MX__erase__1(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1);
+void
+    casadi__MX__erase__1(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::erase"
+// cWrapperName: "casadi__MX__erase__2"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__erase__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__erase__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1);
+void
+    casadi__MX__erase__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::erase"
+// cWrapperName: "casadi__MX__erase__3"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__erase__3(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// call: "        obj->erase(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__MX__erase__3(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
+void
+    casadi__MX__erase__3(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->erase(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "eye" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::eye"
+// cWrapperName: "casadi__MX__eye"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__eye(std::string ** err_msg, int x0)"
+// call: "        casadi::MX ret = casadi::MX::eye(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__eye(std::string ** err_msg, int x0);
+casadi::MX*
+    casadi__MX__eye(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::eye(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get"
+// cWrapperName: "casadi__MX__get__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get__0(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get__0(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__MX__get__0(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get"
+// cWrapperName: "casadi__MX__get__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get__1(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get__1(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__MX__get__1(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get"
+// cWrapperName: "casadi__MX__get__2"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get__2(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get__2(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__MX__get__2(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get"
+// cWrapperName: "casadi__MX__get__3"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get__3(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get__3(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__MX__get__3(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get"
+// cWrapperName: "casadi__MX__get__4"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get__4(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get__4(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__MX__get__4(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get"
+// cWrapperName: "casadi__MX__get__5"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get__5(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get__5(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2);
+void
+    casadi__MX__get__5(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get"
+// cWrapperName: "casadi__MX__get__6"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get__6(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get__6(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2);
+void
+    casadi__MX__get__6(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "getEqualityCheckingDepth" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::getEqualityCheckingDepth"
+// cWrapperName: "casadi__MX__getEqualityCheckingDepth"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__getEqualityCheckingDepth(std::string ** err_msg)"
+// call: "        int ret = casadi::MX::getEqualityCheckingDepth();"
+// params: []
+extern "C"
+int
+    casadi__MX__getEqualityCheckingDepth(std::string ** err_msg);
+int
+    casadi__MX__getEqualityCheckingDepth(std::string ** err_msg){
+    try {
+
+        int ret = casadi::MX::getEqualityCheckingDepth();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getFunction" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::getFunction"
+// cWrapperName: "casadi__MX__getFunction__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__MX__getFunction__0(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::Function ret = obj->getFunction();"
+// params: []
+extern "C"
+casadi::Function*
+    casadi__MX__getFunction__0(std::string ** err_msg, casadi::MX* obj);
+casadi::Function*
+    casadi__MX__getFunction__0(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::Function ret = obj->getFunction();
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getFunction" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::getFunction"
+// cWrapperName: "casadi__MX__getFunction__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Function")
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function*\n    casadi__MX__getFunction__1(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        casadi::Function ret = obj->getFunction(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Function*
+    casadi__MX__getFunction__1(std::string ** err_msg, casadi::MX* obj, int x0);
+casadi::Function*
+    casadi__MX__getFunction__1(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Function ret = obj->getFunction(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getOutput" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::getOutput"
+// cWrapperName: "casadi__MX__getOutput__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::MX ret = obj->getOutput();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj);
+casadi::MX*
+    casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::MX ret = obj->getOutput();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getOutput" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::getOutput"
+// cWrapperName: "casadi__MX__getOutput__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        casadi::MX ret = obj->getOutput(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0);
+casadi::MX*
+    casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = obj->getOutput(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getTemp" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::getTemp"
+// cWrapperName: "casadi__MX__getTemp"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->getTemp();"
+// params: []
+extern "C"
+int
+    casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->getTemp();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_colind" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get_colind"
+// cWrapperName: "casadi__MX__get_colind"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__MX__get_colind(std::string ** err_msg, casadi::MX* obj)"
+// call: "        std::vector< int > ret = obj->get_colind();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__MX__get_colind(std::string ** err_msg, casadi::MX* obj);
+std::vector< int >*
+    casadi__MX__get_colind(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        std::vector< int > ret = obj->get_colind();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "get_input" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get_input"
+// cWrapperName: "casadi__MX__get_input"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__MX__get_input(std::string ** err_msg, casadi::Function* x0)"
+// call: "        std::vector< casadi::MX > ret = casadi::MX::get_input(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__MX__get_input(std::string ** err_msg, casadi::Function* x0);
+std::vector< casadi::MX* >*
+    casadi__MX__get_input(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        std::vector< casadi::MX > ret = casadi::MX::get_input(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get_nz"
+// cWrapperName: "casadi__MX__get_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get_nz__0(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get_nz__0(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2);
+void
+    casadi__MX__get_nz__0(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get_nz"
+// cWrapperName: "casadi__MX__get_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__get_nz__1(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "MX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__get_nz__1(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2);
+void
+    casadi__MX__get_nz__1(std::string ** err_msg, casadi::MX* obj, casadi::MX** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::MX x0_ = casadi::MX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_output" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get_output"
+// cWrapperName: "casadi__MX__get_output"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__get_output(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->get_output();"
+// params: []
+extern "C"
+int
+    casadi__MX__get_output(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__get_output(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->get_output();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_row" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get_row"
+// cWrapperName: "casadi__MX__get_row"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__MX__get_row(std::string ** err_msg, casadi::MX* obj)"
+// call: "        std::vector< int > ret = obj->get_row();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__MX__get_row(std::string ** err_msg, casadi::MX* obj);
+std::vector< int >*
+    casadi__MX__get_row(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        std::vector< int > ret = obj->get_row();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_sparsity" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::get_sparsity"
+// cWrapperName: "casadi__MX__get_sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__MX__get_sparsity(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::Sparsity ret = obj->get_sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__MX__get_sparsity(std::string ** err_msg, casadi::MX* obj);
+casadi::Sparsity*
+    casadi__MX__get_sparsity(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::Sparsity ret = obj->get_sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::grad"
+// cWrapperName: "casadi__MX__grad__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::MX*
+    casadi__MX__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::grad"
+// cWrapperName: "casadi__MX__grad__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::MX*
+    casadi__MX__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::grad"
+// cWrapperName: "casadi__MX__grad__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::MX ret = casadi::MX::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::MX*
+    casadi__MX__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::grad"
+// cWrapperName: "casadi__MX__grad__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::MX*
+    casadi__MX__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::grad"
+// cWrapperName: "casadi__MX__grad__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__grad__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::MX ret = casadi::MX::grad(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__grad__4(std::string ** err_msg, casadi::Function* x0);
+casadi::MX*
+    casadi__MX__grad__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::grad(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::grad"
+// cWrapperName: "casadi__MX__grad__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__grad__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__grad__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::MX*
+    casadi__MX__grad__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::grad"
+// cWrapperName: "casadi__MX__grad__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::MX*
+    casadi__MX__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_duplicates" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::has_duplicates"
+// cWrapperName: "casadi__MX__has_duplicates"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__has_duplicates(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->has_duplicates();"
+// params: []
+extern "C"
+int
+    casadi__MX__has_duplicates(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__has_duplicates(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->has_duplicates();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::inf"
+// cWrapperName: "casadi__MX__inf__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::MX ret = casadi::MX::inf(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::MX*
+    casadi__MX__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::inf"
+// cWrapperName: "casadi__MX__inf__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__inf__1(std::string ** err_msg)"
+// call: "        casadi::MX ret = casadi::MX::inf();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__inf__1(std::string ** err_msg);
+casadi::MX*
+    casadi__MX__inf__1(std::string ** err_msg){
+    try {
+
+        casadi::MX ret = casadi::MX::inf();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::inf"
+// cWrapperName: "casadi__MX__inf__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__inf__2(std::string ** err_msg, int x0)"
+// call: "        casadi::MX ret = casadi::MX::inf(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__inf__2(std::string ** err_msg, int x0);
+casadi::MX*
+    casadi__MX__inf__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::inf"
+// cWrapperName: "casadi__MX__inf__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__inf__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::inf(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__inf__3(std::string ** err_msg, int x0, int x1);
+casadi::MX*
+    casadi__MX__inf__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::inf(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::inf"
+// cWrapperName: "casadi__MX__inf__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::MX ret = casadi::MX::inf(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::MX*
+    casadi__MX__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_binary" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_binary"
+// cWrapperName: "casadi__MX__is_binary"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_binary(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_binary();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_binary(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_binary(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_binary();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_call" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_call"
+// cWrapperName: "casadi__MX__is_call"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_call(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_call();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_call(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_call(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_call();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_column" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_column"
+// cWrapperName: "casadi__MX__is_column"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_column(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_column();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_column(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_column(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_column();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_commutative" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_commutative"
+// cWrapperName: "casadi__MX__is_commutative"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_commutative(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_commutative();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_commutative(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_commutative(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_commutative();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_constant" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_constant"
+// cWrapperName: "casadi__MX__is_constant"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_constant(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_constant();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_constant(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_constant(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_constant();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_dense" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_dense"
+// cWrapperName: "casadi__MX__is_dense"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_dense(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_dense();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_dense(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_dense(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_dense();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_empty"
+// cWrapperName: "casadi__MX__is_empty__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_empty__0(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_empty();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_empty__0(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_empty__0(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_empty();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_empty"
+// cWrapperName: "casadi__MX__is_empty__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_empty__1(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        bool ret = obj->is_empty(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__MX__is_empty__1(std::string ** err_msg, casadi::MX* obj, int x0);
+int
+    casadi__MX__is_empty__1(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_empty(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_identity" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_identity"
+// cWrapperName: "casadi__MX__is_identity"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_identity(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_identity();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_identity(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_identity(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_identity();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_minus_one" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_minus_one"
+// cWrapperName: "casadi__MX__is_minus_one"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_minus_one(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_minus_one();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_minus_one(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_minus_one(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_minus_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_multiplication" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_multiplication"
+// cWrapperName: "casadi__MX__is_multiplication"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_multiplication(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_multiplication();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_multiplication(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_multiplication(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_multiplication();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_norm" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_norm"
+// cWrapperName: "casadi__MX__is_norm"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_norm(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_norm();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_norm(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_norm(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_norm();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_one" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_one"
+// cWrapperName: "casadi__MX__is_one"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_one(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_one();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_one(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_one(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_op" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_op"
+// cWrapperName: "casadi__MX__is_op"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_op(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        bool ret = obj->is_op(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__MX__is_op(std::string ** err_msg, casadi::MX* obj, int x0);
+int
+    casadi__MX__is_op(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        bool ret = obj->is_op(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_output" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_output"
+// cWrapperName: "casadi__MX__is_output"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_output(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_output();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_output(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_output(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_output();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_regular" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_regular"
+// cWrapperName: "casadi__MX__is_regular"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_regular(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_regular();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_regular(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_regular(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_regular();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_row" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_row"
+// cWrapperName: "casadi__MX__is_row"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_row(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_row();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_row(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_row(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_row();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_scalar"
+// cWrapperName: "casadi__MX__is_scalar__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_scalar__0(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_scalar();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_scalar__0(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_scalar__0(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_scalar();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_scalar"
+// cWrapperName: "casadi__MX__is_scalar__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_scalar__1(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        bool ret = obj->is_scalar(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__MX__is_scalar__1(std::string ** err_msg, casadi::MX* obj, int x0);
+int
+    casadi__MX__is_scalar__1(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_square" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_square"
+// cWrapperName: "casadi__MX__is_square"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_square(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_square();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_square(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_square(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_square();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_symbolic" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_symbolic"
+// cWrapperName: "casadi__MX__is_symbolic"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_symbolic(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_symbolic();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_symbolic(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_symbolic(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_symbolic();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_transpose" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_transpose"
+// cWrapperName: "casadi__MX__is_transpose"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_transpose(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_transpose();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_transpose(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_transpose(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_transpose();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_tril" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_tril"
+// cWrapperName: "casadi__MX__is_tril"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_tril(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_tril();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_tril(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_tril(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_tril();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_triu" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_triu"
+// cWrapperName: "casadi__MX__is_triu"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_triu(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_triu();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_triu(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_triu(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_triu();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_unary" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_unary"
+// cWrapperName: "casadi__MX__is_unary"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_unary(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_unary();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_unary(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_unary(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_unary();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_valid_input" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_valid_input"
+// cWrapperName: "casadi__MX__is_valid_input"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_valid_input(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_valid_input();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_valid_input(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_valid_input(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_valid_input();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_vector" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_vector"
+// cWrapperName: "casadi__MX__is_vector"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_vector(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_vector();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_vector(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_vector(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_zero" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::is_zero"
+// cWrapperName: "casadi__MX__is_zero"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__is_zero(std::string ** err_msg, casadi::MX* obj)"
+// call: "        bool ret = obj->is_zero();"
+// params: []
+extern "C"
+int
+    casadi__MX__is_zero(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__is_zero(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        bool ret = obj->is_zero();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::MX*
+    casadi__MX__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3);
+casadi::MX*
+    casadi__MX__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4);
+casadi::MX*
+    casadi__MX__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::MX*
+    casadi__MX__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3);
+casadi::MX*
+    casadi__MX__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4);
+casadi::MX*
+    casadi__MX__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::MX*
+    casadi__MX__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::MX*
+    casadi__MX__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3);
+casadi::MX*
+    casadi__MX__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4);
+casadi::MX*
+    casadi__MX__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__10"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__10(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__10(std::string ** err_msg, casadi::Function* x0);
+casadi::MX*
+    casadi__MX__jac__10(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::jac(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__11"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__11(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__11(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::MX*
+    casadi__MX__jac__11(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__12"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::MX*
+    casadi__MX__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__13"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3);
+casadi::MX*
+    casadi__MX__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::jac"
+// cWrapperName: "casadi__MX__jac__14"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// call: "        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4);
+casadi::MX*
+    casadi__MX__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::MX ret = casadi::MX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "join_primitives" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::join_primitives"
+// cWrapperName: "casadi__MX__join_primitives"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__join_primitives(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0)"
+// call: "        casadi::MX ret = obj->join_primitives(x0_);"
+// params: [(Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__join_primitives(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0);
+casadi::MX*
+    casadi__MX__join_primitives(std::string ** err_msg, casadi::MX* obj, std::vector< casadi::MX* >* x0){
+    try {
+        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
+
+        casadi::MX ret = obj->join_primitives(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "mapping" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::mapping"
+// cWrapperName: "casadi__MX__mapping"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "IM")
+// cWrapperRetType: "casadi::IM*"
+// proto: "casadi::IM*\n    casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::IM ret = obj->mapping();"
+// params: []
+extern "C"
+casadi::IM*
+    casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj);
+casadi::IM*
+    casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::IM ret = obj->mapping();
+
+        return WrapReturn< casadi::IM*, casadi::IM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "monitor" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::monitor"
+// cWrapperName: "casadi__MX__monitor"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__monitor(std::string ** err_msg, casadi::MX* obj, std::string* x0)"
+// call: "        casadi::MX ret = obj->monitor(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__monitor(std::string ** err_msg, casadi::MX* obj, std::string* x0);
+casadi::MX*
+    casadi__MX__monitor(std::string ** err_msg, casadi::MX* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = obj->monitor(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_dep" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::n_dep"
+// cWrapperName: "casadi__MX__n_dep"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__n_dep(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->n_dep();"
+// params: []
+extern "C"
+int
+    casadi__MX__n_dep(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__n_dep(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->n_dep();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_out" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::n_out"
+// cWrapperName: "casadi__MX__n_out"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__n_out(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->n_out();"
+// params: []
+extern "C"
+int
+    casadi__MX__n_out(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__n_out(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->n_out();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_primitives" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::n_primitives"
+// cWrapperName: "casadi__MX__n_primitives"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__n_primitives(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->n_primitives();"
+// params: []
+extern "C"
+int
+    casadi__MX__n_primitives(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__n_primitives(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->n_primitives();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::name"
+// cWrapperName: "casadi__MX__name"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__MX__name(std::string ** err_msg, casadi::MX* obj)"
+// call: "        std::string ret = obj->name();"
+// params: []
+extern "C"
+std::string*
+    casadi__MX__name(std::string ** err_msg, casadi::MX* obj);
+std::string*
+    casadi__MX__name(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        std::string ret = obj->name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nan"
+// cWrapperName: "casadi__MX__nan__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::MX ret = casadi::MX::nan(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::MX*
+    casadi__MX__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nan"
+// cWrapperName: "casadi__MX__nan__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__nan__1(std::string ** err_msg)"
+// call: "        casadi::MX ret = casadi::MX::nan();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__nan__1(std::string ** err_msg);
+casadi::MX*
+    casadi__MX__nan__1(std::string ** err_msg){
+    try {
+
+        casadi::MX ret = casadi::MX::nan();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nan"
+// cWrapperName: "casadi__MX__nan__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__nan__2(std::string ** err_msg, int x0)"
+// call: "        casadi::MX ret = casadi::MX::nan(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__nan__2(std::string ** err_msg, int x0);
+casadi::MX*
+    casadi__MX__nan__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nan"
+// cWrapperName: "casadi__MX__nan__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__nan__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::nan(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__nan__3(std::string ** err_msg, int x0, int x1);
+casadi::MX*
+    casadi__MX__nan__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::nan(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nan"
+// cWrapperName: "casadi__MX__nan__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::MX ret = casadi::MX::nan(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::MX*
+    casadi__MX__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nnz"
+// cWrapperName: "casadi__MX__nnz"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__nnz(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->nnz();"
+// params: []
+extern "C"
+int
+    casadi__MX__nnz(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__nnz(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->nnz();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_diag" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nnz_diag"
+// cWrapperName: "casadi__MX__nnz_diag"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__nnz_diag(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->nnz_diag();"
+// params: []
+extern "C"
+int
+    casadi__MX__nnz_diag(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__nnz_diag(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->nnz_diag();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_lower" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nnz_lower"
+// cWrapperName: "casadi__MX__nnz_lower"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__nnz_lower(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->nnz_lower();"
+// params: []
+extern "C"
+int
+    casadi__MX__nnz_lower(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__nnz_lower(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->nnz_lower();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_upper" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::nnz_upper"
+// cWrapperName: "casadi__MX__nnz_upper"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__nnz_upper(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->nnz_upper();"
+// params: []
+extern "C"
+int
+    casadi__MX__nnz_upper(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__nnz_upper(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->nnz_upper();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numFunctions" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::numFunctions"
+// cWrapperName: "casadi__MX__numFunctions"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__numFunctions(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->numFunctions();"
+// params: []
+extern "C"
+int
+    casadi__MX__numFunctions(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__numFunctions(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->numFunctions();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::numel"
+// cWrapperName: "casadi__MX__numel__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__numel__0(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        int ret = obj->numel(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__MX__numel__0(std::string ** err_msg, casadi::MX* obj, int x0);
+int
+    casadi__MX__numel__0(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->numel(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::numel"
+// cWrapperName: "casadi__MX__numel__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__numel__1(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->numel();"
+// params: []
+extern "C"
+int
+    casadi__MX__numel__1(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__numel__1(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->numel();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::ones"
+// cWrapperName: "casadi__MX__ones__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::MX ret = casadi::MX::ones(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::MX*
+    casadi__MX__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::ones"
+// cWrapperName: "casadi__MX__ones__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::MX ret = casadi::MX::ones(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::MX*
+    casadi__MX__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::ones"
+// cWrapperName: "casadi__MX__ones__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__ones__2(std::string ** err_msg)"
+// call: "        casadi::MX ret = casadi::MX::ones();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__ones__2(std::string ** err_msg);
+casadi::MX*
+    casadi__MX__ones__2(std::string ** err_msg){
+    try {
+
+        casadi::MX ret = casadi::MX::ones();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::ones"
+// cWrapperName: "casadi__MX__ones__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__ones__3(std::string ** err_msg, int x0)"
+// call: "        casadi::MX ret = casadi::MX::ones(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__ones__3(std::string ** err_msg, int x0);
+casadi::MX*
+    casadi__MX__ones__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::ones"
+// cWrapperName: "casadi__MX__ones__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__ones__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::ones(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__ones__4(std::string ** err_msg, int x0, int x1);
+casadi::MX*
+    casadi__MX__ones__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::ones(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "op" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::op"
+// cWrapperName: "casadi__MX__op"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__op(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->op();"
+// params: []
+extern "C"
+int
+    casadi__MX__op(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__op(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->op();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator -" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::operator -"
+// cWrapperName: "casadi__MX__operator__minus"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__operator__minus(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::MX ret = obj->operator -();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__operator__minus(std::string ** err_msg, casadi::MX* obj);
+casadi::MX*
+    casadi__MX__operator__minus(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::MX ret = obj->operator -();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator casadi::Matrix<double>" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::operator casadi::Matrix<double>"
+// cWrapperName: "casadi__MX__operator_casadi__Matrix_double_"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "DM")
+// cWrapperRetType: "casadi::DM*"
+// proto: "casadi::DM*\n    casadi__MX__operator_casadi__Matrix_double_(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::DM ret = obj->operator casadi::Matrix<double>();"
+// params: []
+extern "C"
+casadi::DM*
+    casadi__MX__operator_casadi__Matrix_double_(std::string ** err_msg, casadi::MX* obj);
+casadi::DM*
+    casadi__MX__operator_casadi__Matrix_double_(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::DM ret = obj->operator casadi::Matrix<double>();
+
+        return WrapReturn< casadi::DM*, casadi::DM >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator double" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::operator double"
+// cWrapperName: "casadi__MX__operator_double"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__MX__operator_double(std::string ** err_msg, casadi::MX* obj)"
+// call: "        double ret = obj->operator double();"
+// params: []
+extern "C"
+double
+    casadi__MX__operator_double(std::string ** err_msg, casadi::MX* obj);
+double
+    casadi__MX__operator_double(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        double ret = obj->operator double();
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "primitives" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::primitives"
+// cWrapperName: "casadi__MX__primitives"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__MX__primitives(std::string ** err_msg, casadi::MX* obj)"
+// call: "        std::vector< casadi::MX > ret = obj->primitives();"
+// params: []
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__MX__primitives(std::string ** err_msg, casadi::MX* obj);
+std::vector< casadi::MX* >*
+    casadi__MX__primitives(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        std::vector< casadi::MX > ret = obj->primitives();
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "printme" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::printme"
+// cWrapperName: "casadi__MX__printme"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
+// call: "        casadi::MX ret = obj->printme(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
+casadi::MX*
+    casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        casadi::MX ret = obj->printme(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "resetInput" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::resetInput"
+// cWrapperName: "casadi__MX__resetInput"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__resetInput(std::string ** err_msg, casadi::MX* obj)"
+// call: "        obj->resetInput();"
+// params: []
+extern "C"
+void
+    casadi__MX__resetInput(std::string ** err_msg, casadi::MX* obj);
+void
+    casadi__MX__resetInput(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        obj->resetInput();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "row" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::row"
+// cWrapperName: "casadi__MX__row"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__row(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        int ret = obj->row(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__MX__row(std::string ** err_msg, casadi::MX* obj, int x0);
+int
+    casadi__MX__row(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->row(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set"
+// cWrapperName: "casadi__MX__set__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__MX__set__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set"
+// cWrapperName: "casadi__MX__set__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__MX__set__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set"
+// cWrapperName: "casadi__MX__set__2"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__MX__set__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set"
+// cWrapperName: "casadi__MX__set__3"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__MX__set__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set"
+// cWrapperName: "casadi__MX__set__4"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__MX__set__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set"
+// cWrapperName: "casadi__MX__set__5"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2);
+void
+    casadi__MX__set__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set"
+// cWrapperName: "casadi__MX__set__6"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2);
+void
+    casadi__MX__set__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::setEqualityCheckingDepth"
+// cWrapperName: "casadi__MX__setEqualityCheckingDepth__0"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg)"
+// call: "        casadi::MX::setEqualityCheckingDepth();"
+// params: []
+extern "C"
+void
+    casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg);
+void
+    casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg){
+    try {
+
+        casadi::MX::setEqualityCheckingDepth();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::setEqualityCheckingDepth"
+// cWrapperName: "casadi__MX__setEqualityCheckingDepth__1"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
+// call: "        casadi::MX::setEqualityCheckingDepth(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
+void
+    casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX::setEqualityCheckingDepth(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "setTemp" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::setTemp"
+// cWrapperName: "casadi__MX__setTemp"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        obj->setTemp(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0);
+void
+    casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        obj->setTemp(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set_nz"
+// cWrapperName: "casadi__MX__set_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set_nz__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set_nz__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2);
+void
+    casadi__MX__set_nz__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::set_nz"
+// cWrapperName: "casadi__MX__set_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__MX__set_nz__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__MX__set_nz__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2);
+void
+    casadi__MX__set_nz__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::size"
+// cWrapperName: "casadi__MX__size__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__size__0(std::string ** err_msg, casadi::MX* obj, int x0)"
+// call: "        int ret = obj->size(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__MX__size__0(std::string ** err_msg, casadi::MX* obj, int x0);
+int
+    casadi__MX__size__0(std::string ** err_msg, casadi::MX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::size"
+// cWrapperName: "casadi__MX__size__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__MX__size__1(std::string ** err_msg, casadi::MX* obj)"
+// call: "        std::pair< int, int > ret = obj->size();"
+// params: []
+extern "C"
+std::pair< int, int >*
+    casadi__MX__size__1(std::string ** err_msg, casadi::MX* obj);
+std::pair< int, int >*
+    casadi__MX__size__1(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        std::pair< int, int > ret = obj->size();
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::size1"
+// cWrapperName: "casadi__MX__size1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__size1(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->size1();"
+// params: []
+extern "C"
+int
+    casadi__MX__size1(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__size1(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->size1();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::size2"
+// cWrapperName: "casadi__MX__size2"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__MX__size2(std::string ** err_msg, casadi::MX* obj)"
+// call: "        int ret = obj->size2();"
+// params: []
+extern "C"
+int
+    casadi__MX__size2(std::string ** err_msg, casadi::MX* obj);
+int
+    casadi__MX__size2(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        int ret = obj->size2();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sparsity"
+// cWrapperName: "casadi__MX__sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
+// args: "()"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__MX__sparsity(std::string ** err_msg, casadi::MX* obj)"
+// call: "        casadi::Sparsity ret = obj->sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__MX__sparsity(std::string ** err_msg, casadi::MX* obj);
+casadi::Sparsity*
+    casadi__MX__sparsity(std::string ** err_msg, casadi::MX* obj){
+    try {
+
+        casadi::Sparsity ret = obj->sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "split_primitives" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::split_primitives"
+// cWrapperName: "casadi__MX__split_primitives"
+// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__MX__split_primitives(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
+// call: "        std::vector< casadi::MX > ret = obj->split_primitives(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__MX__split_primitives(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
+std::vector< casadi::MX* >*
+    casadi__MX__split_primitives(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
+    try {
+        casadi::MX& x0_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x0);
+
+        std::vector< casadi::MX > ret = obj->split_primitives(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
+// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
+// proto: "std::vector< std::vector< casadi::MX* >* >*\n    casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// call: "        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::MX* >* >*
+    casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
+std::vector< std::vector< casadi::MX* >* >*
+    casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        int x4_ = Marshaling<int,int>::marshal(x4);
+
+        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
+// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
+// proto: "std::vector< std::vector< casadi::MX* >* >*\n    casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// call: "        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::MX* >* >*
+    casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
+std::vector< std::vector< casadi::MX* >* >*
+    casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__2"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// call: "        std::vector< casadi::MX > ret = casadi::MX::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
+std::vector< casadi::MX* >*
+    casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< casadi::MX > ret = casadi::MX::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__3"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
+// cWrapperRetType: "std::vector< casadi::MX* >*"
+// proto: "std::vector< casadi::MX* >*\n    casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// call: "        std::vector< casadi::MX > ret = casadi::MX::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::MX* >*
+    casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
+std::vector< casadi::MX* >*
+    casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        std::vector< casadi::MX > ret = casadi::MX::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__4"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// call: "        casadi::MX ret = casadi::MX::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
+casadi::MX*
+    casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__5"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// call: "        casadi::MX ret = casadi::MX::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
+casadi::MX*
+    casadi__MX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__6"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__sym__6(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::MX ret = casadi::MX::sym(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__sym__6(std::string ** err_msg, std::string* x0);
+casadi::MX*
+    casadi__MX__sym__6(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::sym(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__7"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1);
+casadi::MX*
+    casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::sym"
+// cWrapperName: "casadi__MX__sym__8"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// call: "        casadi::MX ret = casadi::MX::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
+casadi::MX*
+    casadi__MX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::tang"
+// cWrapperName: "casadi__MX__tang__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::MX*
+    casadi__MX__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::tang"
+// cWrapperName: "casadi__MX__tang__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::MX*
+    casadi__MX__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::tang"
+// cWrapperName: "casadi__MX__tang__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::MX ret = casadi::MX::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::MX*
+    casadi__MX__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::tang"
+// cWrapperName: "casadi__MX__tang__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::MX*
+    casadi__MX__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::tang"
+// cWrapperName: "casadi__MX__tang__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__tang__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::MX ret = casadi::MX::tang(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__tang__4(std::string ** err_msg, casadi::Function* x0);
+casadi::MX*
+    casadi__MX__tang__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::tang(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::tang"
+// cWrapperName: "casadi__MX__tang__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__tang__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__tang__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::MX*
+    casadi__MX__tang__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::tang"
+// cWrapperName: "casadi__MX__tang__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::MX*
+    casadi__MX__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::MX ret = casadi::MX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "type_name" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::type_name"
+// cWrapperName: "casadi__MX__type_name"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__MX__type_name(std::string ** err_msg)"
+// call: "        std::string ret = casadi::MX::type_name();"
+// params: []
+extern "C"
+std::string*
+    casadi__MX__type_name(std::string ** err_msg);
+std::string*
+    casadi__MX__type_name(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::MX::type_name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "unary" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::unary"
+// cWrapperName: "casadi__MX__unary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::MX* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1)"
+// call: "        casadi::MX ret = casadi::MX::unary(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1);
+casadi::MX*
+    casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::MX& x1_ = Marshaling<casadi::MX&,casadi::MX*>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::unary(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::zeros"
+// cWrapperName: "casadi__MX__zeros__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::MX ret = casadi::MX::zeros(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::MX*
+    casadi__MX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::zeros"
+// cWrapperName: "casadi__MX__zeros__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::MX ret = casadi::MX::zeros(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::MX*
+    casadi__MX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::zeros"
+// cWrapperName: "casadi__MX__zeros__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__zeros__2(std::string ** err_msg)"
+// call: "        casadi::MX ret = casadi::MX::zeros();"
+// params: []
+extern "C"
+casadi::MX*
+    casadi__MX__zeros__2(std::string ** err_msg);
+casadi::MX*
+    casadi__MX__zeros__2(std::string ** err_msg){
+    try {
+
+        casadi::MX ret = casadi::MX::zeros();
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::zeros"
+// cWrapperName: "casadi__MX__zeros__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__zeros__3(std::string ** err_msg, int x0)"
+// call: "        casadi::MX ret = casadi::MX::zeros(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__zeros__3(std::string ** err_msg, int x0);
+casadi::MX*
+    casadi__MX__zeros__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::MX ret = casadi::MX::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::MX"
+// cppName: "casadi::MX::zeros"
+// cWrapperName: "casadi__MX__zeros__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "MX")
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX*\n    casadi__MX__zeros__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::MX ret = casadi::MX::zeros(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::MX*
+    casadi__MX__zeros__4(std::string ** err_msg, int x0, int x1);
+casadi::MX*
+    casadi__MX__zeros__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::MX ret = casadi::MX::zeros(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "MatrixCommon")===============
+// classType: UserType (Namespace ["casadi"]) (Name "MatrixCommon")
+extern "C"
+void delete_casadi__MatrixCommon(casadi::MatrixCommon* obj);
+void delete_casadi__MatrixCommon(casadi::MatrixCommon* obj){
+    delete obj;
+}
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "NlpBuilder")===============
+// classType: UserType (Namespace ["casadi"]) (Name "NlpBuilder")
+extern "C"
+void delete_casadi__NlpBuilder(casadi::NlpBuilder* obj);
+void delete_casadi__NlpBuilder(casadi::NlpBuilder* obj){
+    delete obj;
+}
+
+// ================== Normal method: "parse_nl" ===============
+// class: "casadi::NlpBuilder"
+// cppName: "casadi::NlpBuilder::parse_nl"
+// cWrapperName: "casadi__NlpBuilder__parse_nl__0"
+// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__NlpBuilder__parse_nl__0(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0)"
+// call: "        obj->parse_nl(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__NlpBuilder__parse_nl__0(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0);
+void
+    casadi__NlpBuilder__parse_nl__0(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->parse_nl(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "parse_nl" ===============
+// class: "casadi::NlpBuilder"
+// cppName: "casadi::NlpBuilder::parse_nl"
+// cWrapperName: "casadi__NlpBuilder__parse_nl__1"
+// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__NlpBuilder__parse_nl__1(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1)"
+// call: "        obj->parse_nl(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdMap StdString (UserType (Namespace ["casadi"]) (Name "GenericType")))),SwigOutput False)]
+extern "C"
+void
+    casadi__NlpBuilder__parse_nl__1(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1);
+void
+    casadi__NlpBuilder__parse_nl__1(std::string ** err_msg, casadi::NlpBuilder* obj, std::string* x0, std::map< std::string, casadi::GenericType* >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::map< std::string, casadi::GenericType > x1_ = Marshaling<std::map< std::string, casadi::GenericType >,std::map< std::string, casadi::GenericType* >*>::marshal(x1);
+
+        obj->parse_nl(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::NlpBuilder"
+// cppName: "casadi::NlpBuilder::getRepresentation"
+// cWrapperName: "casadi__NlpBuilder__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__NlpBuilder__getRepresentation(std::string ** err_msg, casadi::NlpBuilder* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__NlpBuilder__getRepresentation(std::string ** err_msg, casadi::NlpBuilder* obj);
+std::string*
+    casadi__NlpBuilder__getRepresentation(std::string ** err_msg, casadi::NlpBuilder* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::NlpBuilder"
+// cppName: "casadi::NlpBuilder::getDescription"
+// cWrapperName: "casadi__NlpBuilder__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::NlpBuilder* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__NlpBuilder__getDescription(std::string ** err_msg, casadi::NlpBuilder* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__NlpBuilder__getDescription(std::string ** err_msg, casadi::NlpBuilder* obj);
+std::string*
+    casadi__NlpBuilder__getDescription(std::string ** err_msg, casadi::NlpBuilder* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "SX")===============
+// classType: UserType (Namespace ["casadi"]) (Name "SX")
+extern "C"
+void delete_casadi__SX(casadi::SX* obj);
+void delete_casadi__SX(casadi::SX* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(Ref (Const (StdVec CDouble)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0){
+    try {
+        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, casadi::DM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, casadi::DM* x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "DM"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, casadi::DM* x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, casadi::DM* x0){
+    try {
+        casadi::DM& x0_ = Marshaling<casadi::DM&,casadi::DM*>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, casadi::IM* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, casadi::IM* x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, casadi::IM* x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, casadi::IM* x0){
+    try {
+        casadi::IM& x0_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__4"
+// protoArgs: "(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(Ref (Const (StdVec (StdVec CDouble))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::vector< double >* >* x0){
+    try {
+        std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__5"
+// protoArgs: "(std::string ** err_msg, double x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, double x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(CDouble,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, double x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, double x0){
+    try {
+        double x0_ = Marshaling<double,double>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__6"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, casadi::SX* x1){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__7"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__8"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__9"
+// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::SX* x0)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::SX* x0);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::SX* x0){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX"
+// cWrapperName: "casadi__SX__CONSTRUCTOR__10"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__CONSTRUCTOR__10(std::string ** err_msg)"
+// call: "        casadi::SX* ret = (casadi::SX*)new casadi::SX();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__10(std::string ** err_msg);
+casadi::SX*
+    casadi__SX__CONSTRUCTOR__10(std::string ** err_msg){
+    try {
+
+        casadi::SX* ret = (casadi::SX*)new casadi::SX();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "T" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::T"
+// cWrapperName: "casadi__SX__T"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__T(std::string ** err_msg, casadi::SX* obj)"
+// call: "        casadi::SX ret = obj->T();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__T(std::string ** err_msg, casadi::SX* obj);
+casadi::SX*
+    casadi__SX__T(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        casadi::SX ret = obj->T();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "__nonzero__" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::__nonzero__"
+// cWrapperName: "casadi__SX____nonzero__"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->__nonzero__();"
+// params: []
+extern "C"
+int
+    casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->__nonzero__();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "binary" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::binary"
+// cWrapperName: "casadi__SX__binary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// call: "        casadi::SX ret = casadi::SX::binary(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
+casadi::SX*
+    casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
+        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::binary(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "clear" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::clear"
+// cWrapperName: "casadi__SX__clear"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__clear(std::string ** err_msg, casadi::SX* obj)"
+// call: "        obj->clear();"
+// params: []
+extern "C"
+void
+    casadi__SX__clear(std::string ** err_msg, casadi::SX* obj);
+void
+    casadi__SX__clear(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        obj->clear();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "colind" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::colind"
+// cWrapperName: "casadi__SX__colind"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__colind(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        int ret = obj->colind(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__SX__colind(std::string ** err_msg, casadi::SX* obj, int x0);
+int
+    casadi__SX__colind(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->colind(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::dep"
+// cWrapperName: "casadi__SX__dep__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__dep__0(std::string ** err_msg, casadi::SX* obj)"
+// call: "        casadi::SX ret = obj->dep();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__dep__0(std::string ** err_msg, casadi::SX* obj);
+casadi::SX*
+    casadi__SX__dep__0(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        casadi::SX ret = obj->dep();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dep" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::dep"
+// cWrapperName: "casadi__SX__dep__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__dep__1(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        casadi::SX ret = obj->dep(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__dep__1(std::string ** err_msg, casadi::SX* obj, int x0);
+casadi::SX*
+    casadi__SX__dep__1(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = obj->dep(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dim" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::dim"
+// cWrapperName: "casadi__SX__dim"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__SX__dim(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::string ret = obj->dim();"
+// params: []
+extern "C"
+std::string*
+    casadi__SX__dim(std::string ** err_msg, casadi::SX* obj);
+std::string*
+    casadi__SX__dim(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::string ret = obj->dim();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "element_hash" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::element_hash"
+// cWrapperName: "casadi__SX__element_hash"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__SX__element_hash(std::string ** err_msg, casadi::SX* obj)"
+// call: "        size_t ret = obj->element_hash();"
+// params: []
+extern "C"
+size_t
+    casadi__SX__element_hash(std::string ** err_msg, casadi::SX* obj);
+size_t
+    casadi__SX__element_hash(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        size_t ret = obj->element_hash();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::enlarge"
+// cWrapperName: "casadi__SX__enlarge__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__enlarge__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__enlarge__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+void
+    casadi__SX__enlarge__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        obj->enlarge(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::enlarge"
+// cWrapperName: "casadi__SX__enlarge__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__enlarge__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_, x4_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__enlarge__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
+void
+    casadi__SX__enlarge__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::erase"
+// cWrapperName: "casadi__SX__erase__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__erase__0(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0)"
+// call: "        obj->erase(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__erase__0(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0);
+void
+    casadi__SX__erase__0(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        obj->erase(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::erase"
+// cWrapperName: "casadi__SX__erase__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__erase__1(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__erase__1(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1);
+void
+    casadi__SX__erase__1(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::erase"
+// cWrapperName: "casadi__SX__erase__2"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__erase__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__erase__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1);
+void
+    casadi__SX__erase__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::erase"
+// cWrapperName: "casadi__SX__erase__3"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__erase__3(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// call: "        obj->erase(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__erase__3(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
+void
+    casadi__SX__erase__3(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->erase(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "eye" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::eye"
+// cWrapperName: "casadi__SX__eye"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__eye(std::string ** err_msg, int x0)"
+// call: "        casadi::SX ret = casadi::SX::eye(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__eye(std::string ** err_msg, int x0);
+casadi::SX*
+    casadi__SX__eye(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::eye(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get"
+// cWrapperName: "casadi__SX__get__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get"
+// cWrapperName: "casadi__SX__get__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get"
+// cWrapperName: "casadi__SX__get__2"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get"
+// cWrapperName: "casadi__SX__get__3"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->get(x0_, x1_, x2_, x3_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->get(x0_, x1_, x2_, x3_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get"
+// cWrapperName: "casadi__SX__get__4"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get"
+// cWrapperName: "casadi__SX__get__5"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2);
+void
+    casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get"
+// cWrapperName: "casadi__SX__get__6"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get__6(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get__6(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2);
+void
+    casadi__SX__get__6(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "getEqualityCheckingDepth" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::getEqualityCheckingDepth"
+// cWrapperName: "casadi__SX__getEqualityCheckingDepth"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__getEqualityCheckingDepth(std::string ** err_msg)"
+// call: "        int ret = casadi::SX::getEqualityCheckingDepth();"
+// params: []
+extern "C"
+int
+    casadi__SX__getEqualityCheckingDepth(std::string ** err_msg);
+int
+    casadi__SX__getEqualityCheckingDepth(std::string ** err_msg){
+    try {
+
+        int ret = casadi::SX::getEqualityCheckingDepth();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_colind" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get_colind"
+// cWrapperName: "casadi__SX__get_colind"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__SX__get_colind(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::vector< int > ret = obj->get_colind();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__SX__get_colind(std::string ** err_msg, casadi::SX* obj);
+std::vector< int >*
+    casadi__SX__get_colind(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::vector< int > ret = obj->get_colind();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "get_input" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get_input"
+// cWrapperName: "casadi__SX__get_input"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
+// cWrapperRetType: "std::vector< casadi::SX* >*"
+// proto: "std::vector< casadi::SX* >*\n    casadi__SX__get_input(std::string ** err_msg, casadi::Function* x0)"
+// call: "        std::vector< casadi::SX > ret = casadi::SX::get_input(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+std::vector< casadi::SX* >*
+    casadi__SX__get_input(std::string ** err_msg, casadi::Function* x0);
+std::vector< casadi::SX* >*
+    casadi__SX__get_input(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        std::vector< casadi::SX > ret = casadi::SX::get_input(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nonzeros" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get_nonzeros"
+// cWrapperName: "casadi__SX__get_nonzeros"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SXElem"))
+// cWrapperRetType: "std::vector< casadi::SXElem* >*"
+// proto: "std::vector< casadi::SXElem* >*\n    casadi__SX__get_nonzeros(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::vector< casadi::SXElem > ret = obj->get_nonzeros();"
+// params: []
+extern "C"
+std::vector< casadi::SXElem* >*
+    casadi__SX__get_nonzeros(std::string ** err_msg, casadi::SX* obj);
+std::vector< casadi::SXElem* >*
+    casadi__SX__get_nonzeros(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::vector< casadi::SXElem > ret = obj->get_nonzeros();
+
+        return WrapReturn< std::vector< casadi::SXElem* >*, std::vector< casadi::SXElem > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get_nz"
+// cWrapperName: "casadi__SX__get_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get_nz__0(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get_nz__0(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2);
+void
+    casadi__SX__get_nz__0(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::IM* x2){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get_nz"
+// cWrapperName: "casadi__SX__get_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__get_nz__1(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2)"
+// call: "        obj->get_nz(x0_, x1_, x2_);"
+// params: [(Ref (UserType (Namespace ["casadi"]) (Name "SX")),SwigOutput True),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__get_nz__1(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2);
+void
+    casadi__SX__get_nz__1(std::string ** err_msg, casadi::SX* obj, casadi::SX** x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::SX x0_ = casadi::SX();  // Swig output
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->get_nz(x0_, x1_, x2_);
+        *x0 = WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( x0_ );
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_row" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get_row"
+// cWrapperName: "casadi__SX__get_row"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__SX__get_row(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::vector< int > ret = obj->get_row();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__SX__get_row(std::string ** err_msg, casadi::SX* obj);
+std::vector< int >*
+    casadi__SX__get_row(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::vector< int > ret = obj->get_row();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_sparsity" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::get_sparsity"
+// cWrapperName: "casadi__SX__get_sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__SX__get_sparsity(std::string ** err_msg, casadi::SX* obj)"
+// call: "        casadi::Sparsity ret = obj->get_sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__SX__get_sparsity(std::string ** err_msg, casadi::SX* obj);
+casadi::Sparsity*
+    casadi__SX__get_sparsity(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        casadi::Sparsity ret = obj->get_sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::grad"
+// cWrapperName: "casadi__SX__grad__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::SX*
+    casadi__SX__grad__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::grad"
+// cWrapperName: "casadi__SX__grad__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::SX*
+    casadi__SX__grad__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::grad"
+// cWrapperName: "casadi__SX__grad__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::SX ret = casadi::SX::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::SX*
+    casadi__SX__grad__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::grad"
+// cWrapperName: "casadi__SX__grad__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::SX*
+    casadi__SX__grad__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::grad"
+// cWrapperName: "casadi__SX__grad__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__grad__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::SX ret = casadi::SX::grad(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__grad__4(std::string ** err_msg, casadi::Function* x0);
+casadi::SX*
+    casadi__SX__grad__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::grad(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::grad"
+// cWrapperName: "casadi__SX__grad__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__grad__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::grad(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__grad__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::SX*
+    casadi__SX__grad__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::grad(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "grad" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::grad"
+// cWrapperName: "casadi__SX__grad__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::SX*
+    casadi__SX__grad__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::grad(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_duplicates" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::has_duplicates"
+// cWrapperName: "casadi__SX__has_duplicates"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__has_duplicates(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->has_duplicates();"
+// params: []
+extern "C"
+int
+    casadi__SX__has_duplicates(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__has_duplicates(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->has_duplicates();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_nz" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::has_nz"
+// cWrapperName: "casadi__SX__has_nz"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__has_nz(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
+// call: "        bool ret = obj->has_nz(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__SX__has_nz(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
+int
+    casadi__SX__has_nz(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        bool ret = obj->has_nz(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_zeros" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::has_zeros"
+// cWrapperName: "casadi__SX__has_zeros"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__has_zeros(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->has_zeros();"
+// params: []
+extern "C"
+int
+    casadi__SX__has_zeros(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__has_zeros(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->has_zeros();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::hess"
+// cWrapperName: "casadi__SX__hess__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::SX*
+    casadi__SX__hess__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::hess"
+// cWrapperName: "casadi__SX__hess__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::SX*
+    casadi__SX__hess__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::hess"
+// cWrapperName: "casadi__SX__hess__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::SX ret = casadi::SX::hess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::SX*
+    casadi__SX__hess__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::hess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::hess"
+// cWrapperName: "casadi__SX__hess__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::SX*
+    casadi__SX__hess__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::hess"
+// cWrapperName: "casadi__SX__hess__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__hess__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::SX ret = casadi::SX::hess(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__hess__4(std::string ** err_msg, casadi::Function* x0);
+casadi::SX*
+    casadi__SX__hess__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::hess(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::hess"
+// cWrapperName: "casadi__SX__hess__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__hess__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::hess(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__hess__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::SX*
+    casadi__SX__hess__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::hess(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "hess" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::hess"
+// cWrapperName: "casadi__SX__hess__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::SX*
+    casadi__SX__hess__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::hess(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::inf"
+// cWrapperName: "casadi__SX__inf__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__inf__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::SX ret = casadi::SX::inf(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__inf__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::SX*
+    casadi__SX__inf__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::inf"
+// cWrapperName: "casadi__SX__inf__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__inf__1(std::string ** err_msg)"
+// call: "        casadi::SX ret = casadi::SX::inf();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__inf__1(std::string ** err_msg);
+casadi::SX*
+    casadi__SX__inf__1(std::string ** err_msg){
+    try {
+
+        casadi::SX ret = casadi::SX::inf();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::inf"
+// cWrapperName: "casadi__SX__inf__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__inf__2(std::string ** err_msg, int x0)"
+// call: "        casadi::SX ret = casadi::SX::inf(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__inf__2(std::string ** err_msg, int x0);
+casadi::SX*
+    casadi__SX__inf__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::inf"
+// cWrapperName: "casadi__SX__inf__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__inf__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::inf(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__inf__3(std::string ** err_msg, int x0, int x1);
+casadi::SX*
+    casadi__SX__inf__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::inf(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "inf" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::inf"
+// cWrapperName: "casadi__SX__inf__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__inf__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::SX ret = casadi::SX::inf(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__inf__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::SX*
+    casadi__SX__inf__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::inf(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_column" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_column"
+// cWrapperName: "casadi__SX__is_column"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_column(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_column();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_column(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_column(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_column();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_commutative" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_commutative"
+// cWrapperName: "casadi__SX__is_commutative"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_commutative(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_commutative();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_commutative(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_commutative(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_commutative();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_constant" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_constant"
+// cWrapperName: "casadi__SX__is_constant"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_constant(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_constant();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_constant(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_constant(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_constant();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_dense" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_dense"
+// cWrapperName: "casadi__SX__is_dense"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_dense(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_dense();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_dense(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_dense(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_dense();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_empty"
+// cWrapperName: "casadi__SX__is_empty__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_empty__0(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_empty();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_empty__0(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_empty__0(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_empty();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_empty"
+// cWrapperName: "casadi__SX__is_empty__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_empty__1(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        bool ret = obj->is_empty(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__SX__is_empty__1(std::string ** err_msg, casadi::SX* obj, int x0);
+int
+    casadi__SX__is_empty__1(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_empty(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_identity" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_identity"
+// cWrapperName: "casadi__SX__is_identity"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_identity(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_identity();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_identity(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_identity(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_identity();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_integer" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_integer"
+// cWrapperName: "casadi__SX__is_integer"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_integer(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_integer();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_integer(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_integer(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_integer();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_leaf" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_leaf"
+// cWrapperName: "casadi__SX__is_leaf"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_leaf(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_leaf();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_leaf(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_leaf(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_leaf();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_minus_one" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_minus_one"
+// cWrapperName: "casadi__SX__is_minus_one"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_minus_one(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_minus_one();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_minus_one(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_minus_one(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_minus_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_one" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_one"
+// cWrapperName: "casadi__SX__is_one"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_one(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_one();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_one(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_one(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_one();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_regular" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_regular"
+// cWrapperName: "casadi__SX__is_regular"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_regular(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_regular();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_regular(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_regular(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_regular();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_row" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_row"
+// cWrapperName: "casadi__SX__is_row"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_row(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_row();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_row(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_row(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_row();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_scalar"
+// cWrapperName: "casadi__SX__is_scalar__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_scalar__0(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_scalar();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_scalar__0(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_scalar__0(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_scalar();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_scalar"
+// cWrapperName: "casadi__SX__is_scalar__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_scalar__1(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        bool ret = obj->is_scalar(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__SX__is_scalar__1(std::string ** err_msg, casadi::SX* obj, int x0);
+int
+    casadi__SX__is_scalar__1(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_smooth" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_smooth"
+// cWrapperName: "casadi__SX__is_smooth"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_smooth(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_smooth();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_smooth(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_smooth(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_smooth();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_square" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_square"
+// cWrapperName: "casadi__SX__is_square"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_square(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_square();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_square(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_square(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_square();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_symbolic" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_symbolic"
+// cWrapperName: "casadi__SX__is_symbolic"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_symbolic(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_symbolic();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_symbolic(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_symbolic(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_symbolic();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_tril" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_tril"
+// cWrapperName: "casadi__SX__is_tril"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_tril(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_tril();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_tril(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_tril(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_tril();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_triu" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_triu"
+// cWrapperName: "casadi__SX__is_triu"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_triu(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_triu();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_triu(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_triu(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_triu();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_valid_input" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_valid_input"
+// cWrapperName: "casadi__SX__is_valid_input"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_valid_input(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_valid_input();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_valid_input(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_valid_input(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_valid_input();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_vector" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_vector"
+// cWrapperName: "casadi__SX__is_vector"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_vector(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_vector();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_vector(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_vector(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_zero" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::is_zero"
+// cWrapperName: "casadi__SX__is_zero"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__is_zero(std::string ** err_msg, casadi::SX* obj)"
+// call: "        bool ret = obj->is_zero();"
+// params: []
+extern "C"
+int
+    casadi__SX__is_zero(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__is_zero(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        bool ret = obj->is_zero();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::SX*
+    casadi__SX__jac__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3);
+casadi::SX*
+    casadi__SX__jac__1(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4);
+casadi::SX*
+    casadi__SX__jac__2(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::SX*
+    casadi__SX__jac__3(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3);
+casadi::SX*
+    casadi__SX__jac__4(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4);
+casadi::SX*
+    casadi__SX__jac__5(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::SX*
+    casadi__SX__jac__6(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__7"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::SX*
+    casadi__SX__jac__7(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__8"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3);
+casadi::SX*
+    casadi__SX__jac__8(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__9"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4);
+casadi::SX*
+    casadi__SX__jac__9(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__10"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__10(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__10(std::string ** err_msg, casadi::Function* x0);
+casadi::SX*
+    casadi__SX__jac__10(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::jac(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__11"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__11(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__11(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::SX*
+    casadi__SX__jac__11(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__12"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::SX*
+    casadi__SX__jac__12(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__13"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3);
+casadi::SX*
+    casadi__SX__jac__13(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "jac" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::jac"
+// cWrapperName: "casadi__SX__jac__14"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4)"
+// call: "        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4);
+casadi::SX*
+    casadi__SX__jac__14(std::string ** err_msg, casadi::Function* x0, int x1, int x2, int x3, int x4){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        casadi::SX ret = casadi::SX::jac(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "matrix_matrix" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::matrix_matrix"
+// cWrapperName: "casadi__SX__matrix_matrix"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// call: "        casadi::SX ret = casadi::SX::matrix_matrix(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
+casadi::SX*
+    casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
+        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::matrix_matrix(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "matrix_scalar" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::matrix_scalar"
+// cWrapperName: "casadi__SX__matrix_scalar"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// call: "        casadi::SX ret = casadi::SX::matrix_scalar(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
+casadi::SX*
+    casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
+        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::matrix_scalar(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "n_dep" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::n_dep"
+// cWrapperName: "casadi__SX__n_dep"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__n_dep(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->n_dep();"
+// params: []
+extern "C"
+int
+    casadi__SX__n_dep(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__n_dep(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->n_dep();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::name"
+// cWrapperName: "casadi__SX__name"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__SX__name(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::string ret = obj->name();"
+// params: []
+extern "C"
+std::string*
+    casadi__SX__name(std::string ** err_msg, casadi::SX* obj);
+std::string*
+    casadi__SX__name(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::string ret = obj->name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nan"
+// cWrapperName: "casadi__SX__nan__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__nan__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::SX ret = casadi::SX::nan(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__nan__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::SX*
+    casadi__SX__nan__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nan"
+// cWrapperName: "casadi__SX__nan__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__nan__1(std::string ** err_msg)"
+// call: "        casadi::SX ret = casadi::SX::nan();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__nan__1(std::string ** err_msg);
+casadi::SX*
+    casadi__SX__nan__1(std::string ** err_msg){
+    try {
+
+        casadi::SX ret = casadi::SX::nan();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nan"
+// cWrapperName: "casadi__SX__nan__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__nan__2(std::string ** err_msg, int x0)"
+// call: "        casadi::SX ret = casadi::SX::nan(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__nan__2(std::string ** err_msg, int x0);
+casadi::SX*
+    casadi__SX__nan__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nan"
+// cWrapperName: "casadi__SX__nan__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__nan__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::nan(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__nan__3(std::string ** err_msg, int x0, int x1);
+casadi::SX*
+    casadi__SX__nan__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::nan(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "nan" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nan"
+// cWrapperName: "casadi__SX__nan__4"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__nan__4(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::SX ret = casadi::SX::nan(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__nan__4(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::SX*
+    casadi__SX__nan__4(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::nan(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nnz"
+// cWrapperName: "casadi__SX__nnz"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__nnz(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->nnz();"
+// params: []
+extern "C"
+int
+    casadi__SX__nnz(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__nnz(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->nnz();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_diag" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nnz_diag"
+// cWrapperName: "casadi__SX__nnz_diag"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__nnz_diag(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->nnz_diag();"
+// params: []
+extern "C"
+int
+    casadi__SX__nnz_diag(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__nnz_diag(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->nnz_diag();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_lower" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nnz_lower"
+// cWrapperName: "casadi__SX__nnz_lower"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__nnz_lower(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->nnz_lower();"
+// params: []
+extern "C"
+int
+    casadi__SX__nnz_lower(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__nnz_lower(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->nnz_lower();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_upper" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::nnz_upper"
+// cWrapperName: "casadi__SX__nnz_upper"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__nnz_upper(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->nnz_upper();"
+// params: []
+extern "C"
+int
+    casadi__SX__nnz_upper(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__nnz_upper(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->nnz_upper();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::numel"
+// cWrapperName: "casadi__SX__numel__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__numel__0(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        int ret = obj->numel(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__SX__numel__0(std::string ** err_msg, casadi::SX* obj, int x0);
+int
+    casadi__SX__numel__0(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->numel(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::numel"
+// cWrapperName: "casadi__SX__numel__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__numel__1(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->numel();"
+// params: []
+extern "C"
+int
+    casadi__SX__numel__1(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__numel__1(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->numel();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::ones"
+// cWrapperName: "casadi__SX__ones__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__ones__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::SX ret = casadi::SX::ones(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__ones__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::SX*
+    casadi__SX__ones__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::ones"
+// cWrapperName: "casadi__SX__ones__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__ones__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::SX ret = casadi::SX::ones(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__ones__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::SX*
+    casadi__SX__ones__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::ones"
+// cWrapperName: "casadi__SX__ones__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__ones__2(std::string ** err_msg)"
+// call: "        casadi::SX ret = casadi::SX::ones();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__ones__2(std::string ** err_msg);
+casadi::SX*
+    casadi__SX__ones__2(std::string ** err_msg){
+    try {
+
+        casadi::SX ret = casadi::SX::ones();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::ones"
+// cWrapperName: "casadi__SX__ones__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__ones__3(std::string ** err_msg, int x0)"
+// call: "        casadi::SX ret = casadi::SX::ones(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__ones__3(std::string ** err_msg, int x0);
+casadi::SX*
+    casadi__SX__ones__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::ones(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "ones" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::ones"
+// cWrapperName: "casadi__SX__ones__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__ones__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::ones(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__ones__4(std::string ** err_msg, int x0, int x1);
+casadi::SX*
+    casadi__SX__ones__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::ones(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator +" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::operator +"
+// cWrapperName: "casadi__SX__operator__plus"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__operator__plus(std::string ** err_msg, casadi::SX* obj)"
+// call: "        casadi::SX ret = obj->operator +();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__operator__plus(std::string ** err_msg, casadi::SX* obj);
+casadi::SX*
+    casadi__SX__operator__plus(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        casadi::SX ret = obj->operator +();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator -" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::operator -"
+// cWrapperName: "casadi__SX__operator__minus"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__operator__minus(std::string ** err_msg, casadi::SX* obj)"
+// call: "        casadi::SX ret = obj->operator -();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__operator__minus(std::string ** err_msg, casadi::SX* obj);
+casadi::SX*
+    casadi__SX__operator__minus(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        casadi::SX ret = obj->operator -();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator double" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::operator double"
+// cWrapperName: "casadi__SX__operator_double"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CDouble
+// cWrapperRetType: "double"
+// proto: "double\n    casadi__SX__operator_double(std::string ** err_msg, casadi::SX* obj)"
+// call: "        double ret = obj->operator double();"
+// params: []
+extern "C"
+double
+    casadi__SX__operator_double(std::string ** err_msg, casadi::SX* obj);
+double
+    casadi__SX__operator_double(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        double ret = obj->operator double();
+
+        return WrapReturn< double, double >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator int" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::operator int"
+// cWrapperName: "casadi__SX__operator_int"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__operator_int(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->operator int();"
+// params: []
+extern "C"
+int
+    casadi__SX__operator_int(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__operator_int(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->operator int();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "print_dense" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::print_dense"
+// cWrapperName: "casadi__SX__print_dense"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__print_dense(std::string ** err_msg, casadi::SX* obj)"
+// call: "        obj->print_dense();"
+// params: []
+extern "C"
+void
+    casadi__SX__print_dense(std::string ** err_msg, casadi::SX* obj);
+void
+    casadi__SX__print_dense(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        obj->print_dense();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_scalar" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::print_scalar"
+// cWrapperName: "casadi__SX__print_scalar"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__print_scalar(std::string ** err_msg, casadi::SX* obj)"
+// call: "        obj->print_scalar();"
+// params: []
+extern "C"
+void
+    casadi__SX__print_scalar(std::string ** err_msg, casadi::SX* obj);
+void
+    casadi__SX__print_scalar(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        obj->print_scalar();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_sparse" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::print_sparse"
+// cWrapperName: "casadi__SX__print_sparse"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__print_sparse(std::string ** err_msg, casadi::SX* obj)"
+// call: "        obj->print_sparse();"
+// params: []
+extern "C"
+void
+    casadi__SX__print_sparse(std::string ** err_msg, casadi::SX* obj);
+void
+    casadi__SX__print_sparse(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        obj->print_sparse();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_split" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::print_split"
+// cWrapperName: "casadi__SX__print_split"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__print_split(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1)"
+// call: "        obj->print_split(x0_, x1_);"
+// params: [(Ref (StdVec StdString),SwigOutput True),(Ref (StdVec StdString),SwigOutput True)]
+extern "C"
+void
+    casadi__SX__print_split(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1);
+void
+    casadi__SX__print_split(std::string ** err_msg, casadi::SX* obj, std::vector< std::string* >** x0, std::vector< std::string* >** x1){
+    try {
+        std::vector< std::string > x0_ = std::vector< std::string >();  // Swig output
+        std::vector< std::string > x1_ = std::vector< std::string >();  // Swig output
+
+        obj->print_split(x0_, x1_);
+        *x0 = WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "print_vector" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::print_vector"
+// cWrapperName: "casadi__SX__print_vector"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__print_vector(std::string ** err_msg, casadi::SX* obj)"
+// call: "        obj->print_vector();"
+// params: []
+extern "C"
+void
+    casadi__SX__print_vector(std::string ** err_msg, casadi::SX* obj);
+void
+    casadi__SX__print_vector(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        obj->print_vector();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "printme" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::printme"
+// cWrapperName: "casadi__SX__printme"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
+// call: "        casadi::SX ret = obj->printme(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
+casadi::SX*
+    casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+
+        casadi::SX ret = obj->printme(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "remove" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::remove"
+// cWrapperName: "casadi__SX__remove"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        obj->remove(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1);
+void
+    casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->remove(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reserve" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::reserve"
+// cWrapperName: "casadi__SX__reserve__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
+// call: "        obj->reserve(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
+void
+    casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->reserve(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "reserve" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::reserve"
+// cWrapperName: "casadi__SX__reserve__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        obj->reserve(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0);
+void
+    casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        obj->reserve(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "resetInput" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::resetInput"
+// cWrapperName: "casadi__SX__resetInput"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__resetInput(std::string ** err_msg, casadi::SX* obj)"
+// call: "        obj->resetInput();"
+// params: []
+extern "C"
+void
+    casadi__SX__resetInput(std::string ** err_msg, casadi::SX* obj);
+void
+    casadi__SX__resetInput(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        obj->resetInput();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "resize" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::resize"
+// cWrapperName: "casadi__SX__resize"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
+// call: "        obj->resize(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
+void
+    casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->resize(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "row" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::row"
+// cWrapperName: "casadi__SX__row"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__row(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        int ret = obj->row(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__SX__row(std::string ** err_msg, casadi::SX* obj, int x0);
+int
+    casadi__SX__row(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->row(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sanity_check"
+// cWrapperName: "casadi__SX__sanity_check__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__sanity_check__0(std::string ** err_msg, casadi::SX* obj)"
+// call: "        obj->sanity_check();"
+// params: []
+extern "C"
+void
+    casadi__SX__sanity_check__0(std::string ** err_msg, casadi::SX* obj);
+void
+    casadi__SX__sanity_check__0(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        obj->sanity_check();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sanity_check"
+// cWrapperName: "casadi__SX__sanity_check__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__sanity_check__1(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        obj->sanity_check(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__sanity_check__1(std::string ** err_msg, casadi::SX* obj, int x0);
+void
+    casadi__SX__sanity_check__1(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        obj->sanity_check(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "scalar_matrix" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::scalar_matrix"
+// cWrapperName: "casadi__SX__scalar_matrix"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
+// call: "        casadi::SX ret = casadi::SX::scalar_matrix(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
+casadi::SX*
+    casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
+        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::scalar_matrix(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set"
+// cWrapperName: "casadi__SX__set__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::IM* x3);
+void
+    casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::IM* x3){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set"
+// cWrapperName: "casadi__SX__set__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::Slice* x3);
+void
+    casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2, casadi::Slice* x3){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set"
+// cWrapperName: "casadi__SX__set__2"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IM* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IM* x3);
+void
+    casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::IM* x3){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::IM& x3_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set"
+// cWrapperName: "casadi__SX__set__3"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3)"
+// call: "        obj->set(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3);
+void
+    casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2, casadi::Slice* x3){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+        casadi::Slice& x3_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x3);
+
+        obj->set(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set"
+// cWrapperName: "casadi__SX__set__4"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2);
+void
+    casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Sparsity* x2){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Sparsity& x2_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set"
+// cWrapperName: "casadi__SX__set__5"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2);
+void
+    casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set"
+// cWrapperName: "casadi__SX__set__6"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2);
+void
+    casadi__SX__set__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::setEqualityCheckingDepth"
+// cWrapperName: "casadi__SX__setEqualityCheckingDepth__0"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg)"
+// call: "        casadi::SX::setEqualityCheckingDepth();"
+// params: []
+extern "C"
+void
+    casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg);
+void
+    casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg){
+    try {
+
+        casadi::SX::setEqualityCheckingDepth();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setEqualityCheckingDepth" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::setEqualityCheckingDepth"
+// cWrapperName: "casadi__SX__setEqualityCheckingDepth__1"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
+// call: "        casadi::SX::setEqualityCheckingDepth(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
+void
+    casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX::setEqualityCheckingDepth(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setPrecision" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::setPrecision"
+// cWrapperName: "casadi__SX__setPrecision"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__setPrecision(std::string ** err_msg, int x0)"
+// call: "        casadi::SX::setPrecision(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__setPrecision(std::string ** err_msg, int x0);
+void
+    casadi__SX__setPrecision(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX::setPrecision(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setScientific" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::setScientific"
+// cWrapperName: "casadi__SX__setScientific"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__setScientific(std::string ** err_msg, int x0)"
+// call: "        casadi::SX::setScientific(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__setScientific(std::string ** err_msg, int x0);
+void
+    casadi__SX__setScientific(std::string ** err_msg, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::SX::setScientific(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "setWidth" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::setWidth"
+// cWrapperName: "casadi__SX__setWidth"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__setWidth(std::string ** err_msg, int x0)"
+// call: "        casadi::SX::setWidth(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__SX__setWidth(std::string ** err_msg, int x0);
+void
+    casadi__SX__setWidth(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX::setWidth(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set_nz"
+// cWrapperName: "casadi__SX__set_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set_nz__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "IM"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set_nz__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2);
+void
+    casadi__SX__set_nz__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IM* x2){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::IM& x2_ = Marshaling<casadi::IM&,casadi::IM*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "set_nz" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::set_nz"
+// cWrapperName: "casadi__SX__set_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SX__set_nz__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
+// call: "        obj->set_nz(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CBool,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+void
+    casadi__SX__set_nz__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2);
+void
+    casadi__SX__set_nz__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2){
+    try {
+        casadi::SX& x0_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        casadi::Slice& x2_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x2);
+
+        obj->set_nz(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::size"
+// cWrapperName: "casadi__SX__size__0"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__size__0(std::string ** err_msg, casadi::SX* obj, int x0)"
+// call: "        int ret = obj->size(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__SX__size__0(std::string ** err_msg, casadi::SX* obj, int x0);
+int
+    casadi__SX__size__0(std::string ** err_msg, casadi::SX* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::size"
+// cWrapperName: "casadi__SX__size__1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__SX__size__1(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::pair< int, int > ret = obj->size();"
+// params: []
+extern "C"
+std::pair< int, int >*
+    casadi__SX__size__1(std::string ** err_msg, casadi::SX* obj);
+std::pair< int, int >*
+    casadi__SX__size__1(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::pair< int, int > ret = obj->size();
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::size1"
+// cWrapperName: "casadi__SX__size1"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__size1(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->size1();"
+// params: []
+extern "C"
+int
+    casadi__SX__size1(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__size1(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->size1();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::size2"
+// cWrapperName: "casadi__SX__size2"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SX__size2(std::string ** err_msg, casadi::SX* obj)"
+// call: "        int ret = obj->size2();"
+// params: []
+extern "C"
+int
+    casadi__SX__size2(std::string ** err_msg, casadi::SX* obj);
+int
+    casadi__SX__size2(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        int ret = obj->size2();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sparsity" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sparsity"
+// cWrapperName: "casadi__SX__sparsity"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__SX__sparsity(std::string ** err_msg, casadi::SX* obj)"
+// call: "        casadi::Sparsity ret = obj->sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__SX__sparsity(std::string ** err_msg, casadi::SX* obj);
+casadi::Sparsity*
+    casadi__SX__sparsity(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        casadi::Sparsity ret = obj->sparsity();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
+// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
+// proto: "std::vector< std::vector< casadi::SX* >* >*\n    casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
+// call: "        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::SX* >* >*
+    casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
+std::vector< std::vector< casadi::SX* >* >*
+    casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        int x4_ = Marshaling<int,int>::marshal(x4);
+
+        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
+// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
+// proto: "std::vector< std::vector< casadi::SX* >* >*\n    casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
+// call: "        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< std::vector< casadi::SX* >* >*
+    casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
+std::vector< std::vector< casadi::SX* >* >*
+    casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__2"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
+// cWrapperRetType: "std::vector< casadi::SX* >*"
+// proto: "std::vector< casadi::SX* >*\n    casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
+// call: "        std::vector< casadi::SX > ret = casadi::SX::sym(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::SX* >*
+    casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
+std::vector< casadi::SX* >*
+    casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        std::vector< casadi::SX > ret = casadi::SX::sym(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__3"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
+// cWrapperRetType: "std::vector< casadi::SX* >*"
+// proto: "std::vector< casadi::SX* >*\n    casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
+// call: "        std::vector< casadi::SX > ret = casadi::SX::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< casadi::SX* >*
+    casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
+std::vector< casadi::SX* >*
+    casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        std::vector< casadi::SX > ret = casadi::SX::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__4"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// call: "        casadi::SX ret = casadi::SX::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
+casadi::SX*
+    casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__5"
+// protoArgs: "(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1)"
+// call: "        casadi::SX ret = casadi::SX::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1);
+casadi::SX*
+    casadi__SX__sym__5(std::string ** err_msg, std::string* x0, std::pair< int, int >* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        std::pair< int, int > x1_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__6"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__sym__6(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::SX ret = casadi::SX::sym(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__sym__6(std::string ** err_msg, std::string* x0);
+casadi::SX*
+    casadi__SX__sym__6(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::sym(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__7"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::sym(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1);
+casadi::SX*
+    casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::sym(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "sym" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::sym"
+// cWrapperName: "casadi__SX__sym__8"
+// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::sym(x0_, x1_, x2_);"
+// params: [(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2);
+casadi::SX*
+    casadi__SX__sym__8(std::string ** err_msg, std::string* x0, int x1, int x2){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::sym(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::tang"
+// cWrapperName: "casadi__SX__tang__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2);
+casadi::SX*
+    casadi__SX__tang__0(std::string ** err_msg, casadi::Function* x0, std::string* x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::tang"
+// cWrapperName: "casadi__SX__tang__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2)"
+// call: "        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2);
+casadi::SX*
+    casadi__SX__tang__1(std::string ** err_msg, casadi::Function* x0, int x1, std::string* x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::string& x2_ = Marshaling<std::string&,std::string*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::tang"
+// cWrapperName: "casadi__SX__tang__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "        casadi::SX ret = casadi::SX::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::SX*
+    casadi__SX__tang__2(std::string ** err_msg, casadi::Function* x0, std::string* x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::tang"
+// cWrapperName: "casadi__SX__tang__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(Ref (Const StdString),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2);
+casadi::SX*
+    casadi__SX__tang__3(std::string ** err_msg, casadi::Function* x0, std::string* x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        std::string& x1_ = Marshaling<std::string&,std::string*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::tang"
+// cWrapperName: "casadi__SX__tang__4"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__tang__4(std::string ** err_msg, casadi::Function* x0)"
+// call: "        casadi::SX ret = casadi::SX::tang(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__tang__4(std::string ** err_msg, casadi::Function* x0);
+casadi::SX*
+    casadi__SX__tang__4(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::tang(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::tang"
+// cWrapperName: "casadi__SX__tang__5"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__tang__5(std::string ** err_msg, casadi::Function* x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::tang(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__tang__5(std::string ** err_msg, casadi::Function* x0, int x1);
+casadi::SX*
+    casadi__SX__tang__5(std::string ** err_msg, casadi::Function* x0, int x1){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::tang(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "tang" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::tang"
+// cWrapperName: "casadi__SX__tang__6"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2)"
+// call: "        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2);
+casadi::SX*
+    casadi__SX__tang__6(std::string ** err_msg, casadi::Function* x0, int x1, int x2){
+    try {
+        casadi::Function& x0_ = Marshaling<casadi::Function&,casadi::Function*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::tang(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::triplet"
+// cWrapperName: "casadi__SX__triplet__0"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3)"
+// call: "        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3);
+casadi::SX*
+    casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, std::pair< int, int >* x3){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
+        std::pair< int, int > x3_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x3);
+
+        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::triplet"
+// cWrapperName: "casadi__SX__triplet__1"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4)"
+// call: "        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_, x3_, x4_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4);
+casadi::SX*
+    casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2, int x3, int x4){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+        int x4_ = Marshaling<int,int>::marshal(x4);
+
+        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::triplet"
+// cWrapperName: "casadi__SX__triplet__2"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2)"
+// call: "        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2);
+casadi::SX*
+    casadi__SX__triplet__2(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, casadi::SX* x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        casadi::SX& x2_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x2);
+
+        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "type_name" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::type_name"
+// cWrapperName: "casadi__SX__type_name"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__SX__type_name(std::string ** err_msg)"
+// call: "        std::string ret = casadi::SX::type_name();"
+// params: []
+extern "C"
+std::string*
+    casadi__SX__type_name(std::string ** err_msg);
+std::string*
+    casadi__SX__type_name(std::string ** err_msg){
+    try {
+
+        std::string ret = casadi::SX::type_name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "unary" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::unary"
+// cWrapperName: "casadi__SX__unary"
+// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1)"
+// call: "        casadi::SX ret = casadi::SX::unary(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1);
+casadi::SX*
+    casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        casadi::SX& x1_ = Marshaling<casadi::SX&,casadi::SX*>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::unary(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::zeros"
+// cWrapperName: "casadi__SX__zeros__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::SX ret = casadi::SX::zeros(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::SX*
+    casadi__SX__zeros__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::zeros"
+// cWrapperName: "casadi__SX__zeros__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0)"
+// call: "        casadi::SX ret = casadi::SX::zeros(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0);
+casadi::SX*
+    casadi__SX__zeros__1(std::string ** err_msg, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::zeros"
+// cWrapperName: "casadi__SX__zeros__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__zeros__2(std::string ** err_msg)"
+// call: "        casadi::SX ret = casadi::SX::zeros();"
+// params: []
+extern "C"
+casadi::SX*
+    casadi__SX__zeros__2(std::string ** err_msg);
+casadi::SX*
+    casadi__SX__zeros__2(std::string ** err_msg){
+    try {
+
+        casadi::SX ret = casadi::SX::zeros();
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::zeros"
+// cWrapperName: "casadi__SX__zeros__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__zeros__3(std::string ** err_msg, int x0)"
+// call: "        casadi::SX ret = casadi::SX::zeros(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__zeros__3(std::string ** err_msg, int x0);
+casadi::SX*
+    casadi__SX__zeros__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::SX ret = casadi::SX::zeros(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "zeros" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::zeros"
+// cWrapperName: "casadi__SX__zeros__4"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "SX")
+// cWrapperRetType: "casadi::SX*"
+// proto: "casadi::SX*\n    casadi__SX__zeros__4(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::SX ret = casadi::SX::zeros(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::SX*
+    casadi__SX__zeros__4(std::string ** err_msg, int x0, int x1);
+casadi::SX*
+    casadi__SX__zeros__4(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::SX ret = casadi::SX::zeros(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::getRepresentation"
+// cWrapperName: "casadi__SX__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj);
+std::string*
+    casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::SX"
+// cppName: "casadi::SX::getDescription"
+// cWrapperName: "casadi__SX__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj);
+std::string*
+    casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "SXElem")===============
+// classType: UserType (Namespace ["casadi"]) (Name "SXElem")
+extern "C"
+void delete_casadi__SXElem(casadi::SXElem* obj);
+void delete_casadi__SXElem(casadi::SXElem* obj){
+    delete obj;
+}
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "SharedObject")===============
+// classType: UserType (Namespace ["casadi"]) (Name "SharedObject")
+extern "C"
+void delete_casadi__SharedObject(casadi::SharedObject* obj);
+void delete_casadi__SharedObject(casadi::SharedObject* obj){
+    delete obj;
+}
+
+// ================== Normal method: "__hash__" ===============
+// class: "casadi::SharedObject"
+// cppName: "casadi::SharedObject::__hash__"
+// cWrapperName: "casadi__SharedObject____hash__"
+// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__SharedObject____hash__(std::string ** err_msg, casadi::SharedObject* obj)"
+// call: "        size_t ret = obj->__hash__();"
+// params: []
+extern "C"
+size_t
+    casadi__SharedObject____hash__(std::string ** err_msg, casadi::SharedObject* obj);
+size_t
+    casadi__SharedObject____hash__(std::string ** err_msg, casadi::SharedObject* obj){
+    try {
+
+        size_t ret = obj->__hash__();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_null" ===============
+// class: "casadi::SharedObject"
+// cppName: "casadi::SharedObject::is_null"
+// cWrapperName: "casadi__SharedObject__is_null"
+// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__SharedObject__is_null(std::string ** err_msg, casadi::SharedObject* obj)"
+// call: "        bool ret = obj->is_null();"
+// params: []
+extern "C"
+int
+    casadi__SharedObject__is_null(std::string ** err_msg, casadi::SharedObject* obj);
+int
+    casadi__SharedObject__is_null(std::string ** err_msg, casadi::SharedObject* obj){
+    try {
+
+        bool ret = obj->is_null();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "printPtr" ===============
+// class: "casadi::SharedObject"
+// cppName: "casadi::SharedObject::printPtr"
+// cWrapperName: "casadi__SharedObject__printPtr"
+// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj)"
+// call: "        obj->printPtr();"
+// params: []
+extern "C"
+void
+    casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj);
+void
+    casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj){
+    try {
+
+        obj->printPtr();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::SharedObject"
+// cppName: "casadi::SharedObject::getRepresentation"
+// cWrapperName: "casadi__SharedObject__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj);
+std::string*
+    casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::SharedObject"
+// cppName: "casadi::SharedObject::getDescription"
+// cWrapperName: "casadi__SharedObject__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj);
+std::string*
+    casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "Slice")===============
+// classType: UserType (Namespace ["casadi"]) (Name "Slice")
+extern "C"
+void delete_casadi__Slice(casadi::Slice* obj);
+void delete_casadi__Slice(casadi::Slice* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice"
+// cWrapperName: "casadi__Slice__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
+// cWrapperRetType: "casadi::Slice*"
+// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1);
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice"
+// cWrapperName: "casadi__Slice__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, int x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
+// cWrapperRetType: "casadi::Slice*"
+// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1, int x2)"
+// call: "        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1, int x2);
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1, int x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice"
+// cWrapperName: "casadi__Slice__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
+// cWrapperRetType: "casadi::Slice*"
+// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, int x0)"
+// call: "        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, int x0);
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice"
+// cWrapperName: "casadi__Slice__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
+// cWrapperRetType: "casadi::Slice*"
+// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1);
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice"
+// cWrapperName: "casadi__Slice__CONSTRUCTOR__4"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
+// cWrapperRetType: "casadi::Slice*"
+// proto: "casadi::Slice*\n    casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg)"
+// call: "        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice();"
+// params: []
+extern "C"
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg);
+casadi::Slice*
+    casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg){
+    try {
+
+        casadi::Slice* ret = (casadi::Slice*)new casadi::Slice();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "all" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::all"
+// cWrapperName: "casadi__Slice__all__0"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Slice__all__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1)"
+// call: "        std::vector< int > ret = obj->all(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Slice__all__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1);
+std::vector< int >*
+    casadi__Slice__all__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1){
+    try {
+        casadi::Slice& x0_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        std::vector< int > ret = obj->all(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "all" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::all"
+// cWrapperName: "casadi__Slice__all__1"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Slice__all__1(std::string ** err_msg, casadi::Slice* obj, int x0)"
+// call: "        std::vector< int > ret = obj->all(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Slice__all__1(std::string ** err_msg, casadi::Slice* obj, int x0);
+std::vector< int >*
+    casadi__Slice__all__1(std::string ** err_msg, casadi::Slice* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::vector< int > ret = obj->all(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "all" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::all"
+// cWrapperName: "casadi__Slice__all__2"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Slice__all__2(std::string ** err_msg, casadi::Slice* obj, int x0, int x1)"
+// call: "        std::vector< int > ret = obj->all(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Slice__all__2(std::string ** err_msg, casadi::Slice* obj, int x0, int x1);
+std::vector< int >*
+    casadi__Slice__all__2(std::string ** err_msg, casadi::Slice* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        std::vector< int > ret = obj->all(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::is_scalar"
+// cWrapperName: "casadi__Slice__is_scalar"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Slice__is_scalar(std::string ** err_msg, casadi::Slice* obj, int x0)"
+// call: "        bool ret = obj->is_scalar(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Slice__is_scalar(std::string ** err_msg, casadi::Slice* obj, int x0);
+int
+    casadi__Slice__is_scalar(std::string ** err_msg, casadi::Slice* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        bool ret = obj->is_scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator !=" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::operator !="
+// cWrapperName: "casadi__Slice__operator__nequals"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Slice__operator__nequals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
+// call: "        bool ret = obj->operator !=(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+int
+    casadi__Slice__operator__nequals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0);
+int
+    casadi__Slice__operator__nequals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0){
+    try {
+        casadi::Slice& x0_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x0);
+
+        bool ret = obj->operator !=(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator ==" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::operator =="
+// cWrapperName: "casadi__Slice__operator__equals"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Slice__operator__equals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0)"
+// call: "        bool ret = obj->operator ==(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),SwigOutput False)]
+extern "C"
+int
+    casadi__Slice__operator__equals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0);
+int
+    casadi__Slice__operator__equals(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0){
+    try {
+        casadi::Slice& x0_ = Marshaling<casadi::Slice&,casadi::Slice*>::marshal(x0);
+
+        bool ret = obj->operator ==(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "scalar" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::scalar"
+// cWrapperName: "casadi__Slice__scalar"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Slice__scalar(std::string ** err_msg, casadi::Slice* obj, int x0)"
+// call: "        int ret = obj->scalar(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Slice__scalar(std::string ** err_msg, casadi::Slice* obj, int x0);
+int
+    casadi__Slice__scalar(std::string ** err_msg, casadi::Slice* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::getRepresentation"
+// cWrapperName: "casadi__Slice__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj);
+std::string*
+    casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::Slice"
+// cppName: "casadi::Slice::getDescription"
+// cWrapperName: "casadi__Slice__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::Slice* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj);
+std::string*
+    casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "Sparsity")===============
+// classType: UserType (Namespace ["casadi"]) (Name "Sparsity")
+extern "C"
+void delete_casadi__Sparsity(casadi::Sparsity* obj);
+void delete_casadi__Sparsity(casadi::Sparsity* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity"
+// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity"
+// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity"
+// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg)"
+// call: "        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg);
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg){
+    try {
+
+        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity"
+// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__3"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__CONSTRUCTOR__3(std::string ** err_msg, int x0)"
+// call: "        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__3(std::string ** err_msg, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__CONSTRUCTOR__3(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity* ret = (casadi::Sparsity*)new casadi::Sparsity(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "T" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::T"
+// cWrapperName: "casadi__Sparsity__T"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__T(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        casadi::Sparsity ret = obj->T();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__T(std::string ** err_msg, casadi::Sparsity* obj);
+casadi::Sparsity*
+    casadi__Sparsity__T(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        casadi::Sparsity ret = obj->T();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "add_nz" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::add_nz"
+// cWrapperName: "casadi__Sparsity__add_nz"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__add_nz(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// call: "        int ret = obj->add_nz(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__add_nz(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
+int
+    casadi__Sparsity__add_nz(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        int ret = obj->add_nz(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "append" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::append"
+// cWrapperName: "casadi__Sparsity__append"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        obj->append(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+void
+    casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        obj->append(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "appendColumns" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::appendColumns"
+// cWrapperName: "casadi__Sparsity__appendColumns"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        obj->appendColumns(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+void
+    casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        obj->appendColumns(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "band" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::band"
+// cWrapperName: "casadi__Sparsity__band"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__band(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::band(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__band(std::string ** err_msg, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__band(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = casadi::Sparsity::band(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "banded" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::banded"
+// cWrapperName: "casadi__Sparsity__banded"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::banded(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = casadi::Sparsity::banded(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "btf" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::btf"
+// cWrapperName: "casadi__Sparsity__btf__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__btf__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5)"
+// call: "        int ret = obj->btf(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+int
+    casadi__Sparsity__btf__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5);
+int
+    casadi__Sparsity__btf__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5){
+    try {
+        std::vector< int > x0_ = std::vector< int >();  // Swig output
+        std::vector< int > x1_ = std::vector< int >();  // Swig output
+        std::vector< int > x2_ = std::vector< int >();  // Swig output
+        std::vector< int > x3_ = std::vector< int >();  // Swig output
+        std::vector< int > x4_ = std::vector< int >();  // Swig output
+        std::vector< int > x5_ = std::vector< int >();  // Swig output
+
+        int ret = obj->btf(x0_, x1_, x2_, x3_, x4_, x5_);
+        *x0 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x1_ );
+        *x2 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x2_ );
+        *x3 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x3_ );
+        *x4 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x4_ );
+        *x5 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x5_ );
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "btf" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::btf"
+// cWrapperName: "casadi__Sparsity__btf__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5, int x6)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__btf__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5, int x6)"
+// call: "        int ret = obj->btf(x0_, x1_, x2_, x3_, x4_, x5_, x6_);"
+// params: [(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True),(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__btf__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5, int x6);
+int
+    casadi__Sparsity__btf__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1, std::vector< int >** x2, std::vector< int >** x3, std::vector< int >** x4, std::vector< int >** x5, int x6){
+    try {
+        std::vector< int > x0_ = std::vector< int >();  // Swig output
+        std::vector< int > x1_ = std::vector< int >();  // Swig output
+        std::vector< int > x2_ = std::vector< int >();  // Swig output
+        std::vector< int > x3_ = std::vector< int >();  // Swig output
+        std::vector< int > x4_ = std::vector< int >();  // Swig output
+        std::vector< int > x5_ = std::vector< int >();  // Swig output
+        int x6_ = Marshaling<int,int>::marshal(x6);
+
+        int ret = obj->btf(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
+        *x0 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x1_ );
+        *x2 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x2_ );
+        *x3 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x3_ );
+        *x4 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x4_ );
+        *x5 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x5_ );
+        // x6 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "bw_lower" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::bw_lower"
+// cWrapperName: "casadi__Sparsity__bw_lower"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__bw_lower(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->bw_lower();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__bw_lower(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__bw_lower(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->bw_lower();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "bw_upper" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::bw_upper"
+// cWrapperName: "casadi__Sparsity__bw_upper"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__bw_upper(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->bw_upper();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__bw_upper(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__bw_upper(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->bw_upper();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "colind" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::colind"
+// cWrapperName: "casadi__Sparsity__colind"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__colind(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        int ret = obj->colind(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__colind(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__colind(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->colind(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "combine" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::combine"
+// cWrapperName: "casadi__Sparsity__combine"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__combine(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2)"
+// call: "        casadi::Sparsity ret = obj->combine(x0_, x1_, x2_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__combine(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2);
+casadi::Sparsity*
+    casadi__Sparsity__combine(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Sparsity ret = obj->combine(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "compress" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::compress"
+// cWrapperName: "casadi__Sparsity__compress"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->compress();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->compress();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "compressed" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::compressed"
+// cWrapperName: "casadi__Sparsity__compressed"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::compressed(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0);
+casadi::Sparsity*
+    casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::compressed(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "dense" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::dense"
+// cWrapperName: "casadi__Sparsity__dense__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__dense__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::dense(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__dense__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::Sparsity*
+    casadi__Sparsity__dense__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::dense(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "dense" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::dense"
+// cWrapperName: "casadi__Sparsity__dense__1"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__dense__1(std::string ** err_msg, int x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::dense(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__dense__1(std::string ** err_msg, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__dense__1(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::dense(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "dense" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::dense"
+// cWrapperName: "casadi__Sparsity__dense__2"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__dense__2(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::dense(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__dense__2(std::string ** err_msg, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__dense__2(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = casadi::Sparsity::dense(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dfs" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::dfs"
+// cWrapperName: "casadi__Sparsity__dfs"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__dfs(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
+// call: "        int ret = obj->dfs(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (StdVec CInt),SwigOutput False),(Ref (StdVec CInt),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (StdVec CBool),SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__dfs(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5);
+int
+    casadi__Sparsity__dfs(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
+        std::vector< bool > x5_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x5);
+
+        int ret = obj->dfs(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "diag" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::diag"
+// cWrapperName: "casadi__Sparsity__diag__0"
+// protoArgs: "(std::string ** err_msg, std::pair< int, int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__diag__0(std::string ** err_msg, std::pair< int, int >* x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::diag(x0_);"
+// params: [(Ref (Const (StdPair CInt CInt)),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__diag__0(std::string ** err_msg, std::pair< int, int >* x0);
+casadi::Sparsity*
+    casadi__Sparsity__diag__0(std::string ** err_msg, std::pair< int, int >* x0){
+    try {
+        std::pair< int, int > x0_ = Marshaling<std::pair< int, int >,std::pair< int, int >*>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::diag(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "diag" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::diag"
+// cWrapperName: "casadi__Sparsity__diag__1"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__diag__1(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::diag(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__diag__1(std::string ** err_msg, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__diag__1(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = casadi::Sparsity::diag(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "diag" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::diag"
+// cWrapperName: "casadi__Sparsity__diag__2"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__diag__2(std::string ** err_msg, int x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::diag(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__diag__2(std::string ** err_msg, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__diag__2(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::diag(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "dim" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::dim"
+// cWrapperName: "casadi__Sparsity__dim"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Sparsity__dim(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::string ret = obj->dim();"
+// params: []
+extern "C"
+std::string*
+    casadi__Sparsity__dim(std::string ** err_msg, casadi::Sparsity* obj);
+std::string*
+    casadi__Sparsity__dim(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::string ret = obj->dim();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::enlarge"
+// cWrapperName: "casadi__Sparsity__enlarge__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__enlarge__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__enlarge__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+void
+    casadi__Sparsity__enlarge__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        obj->enlarge(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlarge" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::enlarge"
+// cWrapperName: "casadi__Sparsity__enlarge__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__enlarge__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4)"
+// call: "        obj->enlarge(x0_, x1_, x2_, x3_, x4_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__enlarge__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4);
+void
+    casadi__Sparsity__enlarge__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, int x4){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        bool x4_ = Marshaling<bool,int>::marshal(x4);
+
+        obj->enlarge(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlargeColumns" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::enlargeColumns"
+// cWrapperName: "casadi__Sparsity__enlargeColumns__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__enlargeColumns__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
+// call: "        obj->enlargeColumns(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__enlargeColumns__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1);
+void
+    casadi__Sparsity__enlargeColumns__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->enlargeColumns(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlargeColumns" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::enlargeColumns"
+// cWrapperName: "casadi__Sparsity__enlargeColumns__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__enlargeColumns__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
+// call: "        obj->enlargeColumns(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__enlargeColumns__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2);
+void
+    casadi__Sparsity__enlargeColumns__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->enlargeColumns(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlargeRows" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::enlargeRows"
+// cWrapperName: "casadi__Sparsity__enlargeRows__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__enlargeRows__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
+// call: "        obj->enlargeRows(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__enlargeRows__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1);
+void
+    casadi__Sparsity__enlargeRows__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        obj->enlargeRows(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "enlargeRows" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::enlargeRows"
+// cWrapperName: "casadi__Sparsity__enlargeRows__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__enlargeRows__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2)"
+// call: "        obj->enlargeRows(x0_, x1_, x2_);"
+// params: [(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__enlargeRows__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2);
+void
+    casadi__Sparsity__enlargeRows__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1, int x2){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        obj->enlargeRows(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::erase"
+// cWrapperName: "casadi__Sparsity__erase__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__erase__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// call: "        std::vector< int > ret = obj->erase(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__erase__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
+std::vector< int >*
+    casadi__Sparsity__erase__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        std::vector< int > ret = obj->erase(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::erase"
+// cWrapperName: "casadi__Sparsity__erase__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__erase__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
+// call: "        std::vector< int > ret = obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__erase__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
+std::vector< int >*
+    casadi__Sparsity__erase__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        std::vector< int > ret = obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::erase"
+// cWrapperName: "casadi__Sparsity__erase__2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__erase__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        std::vector< int > ret = obj->erase(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__erase__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
+std::vector< int >*
+    casadi__Sparsity__erase__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        std::vector< int > ret = obj->erase(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "erase" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::erase"
+// cWrapperName: "casadi__Sparsity__erase__3"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__erase__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2)"
+// call: "        std::vector< int > ret = obj->erase(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__erase__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2);
+std::vector< int >*
+    casadi__Sparsity__erase__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, int x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        std::vector< int > ret = obj->erase(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "etree" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::etree"
+// cWrapperName: "casadi__Sparsity__etree__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__etree__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->etree();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__etree__0(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__etree__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->etree();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "etree" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::etree"
+// cWrapperName: "casadi__Sparsity__etree__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__etree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        std::vector< int > ret = obj->etree(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__etree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+std::vector< int >*
+    casadi__Sparsity__etree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        std::vector< int > ret = obj->etree(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "find" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::find"
+// cWrapperName: "casadi__Sparsity__find__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__find__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->find();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__find__0(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__find__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->find();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "find" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::find"
+// cWrapperName: "casadi__Sparsity__find__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__find__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        std::vector< int > ret = obj->find(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__find__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+std::vector< int >*
+    casadi__Sparsity__find__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        std::vector< int > ret = obj->find(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_ccs" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_ccs"
+// cWrapperName: "casadi__Sparsity__get_ccs"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__get_ccs(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// call: "        obj->get_ccs(x0_, x1_);"
+// params: [(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+void
+    casadi__Sparsity__get_ccs(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1);
+void
+    casadi__Sparsity__get_ccs(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1){
+    try {
+        std::vector< int > x0_ = std::vector< int >();  // Swig output
+        std::vector< int > x1_ = std::vector< int >();  // Swig output
+
+        obj->get_ccs(x0_, x1_);
+        *x0 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_col" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_col"
+// cWrapperName: "casadi__Sparsity__get_col"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__get_col(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->get_col();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__get_col(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__get_col(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->get_col();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_colind" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_colind"
+// cWrapperName: "casadi__Sparsity__get_colind"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__get_colind(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->get_colind();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__get_colind(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__get_colind(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->get_colind();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_crs" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_crs"
+// cWrapperName: "casadi__Sparsity__get_crs"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__get_crs(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// call: "        obj->get_crs(x0_, x1_);"
+// params: [(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+void
+    casadi__Sparsity__get_crs(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1);
+void
+    casadi__Sparsity__get_crs(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1){
+    try {
+        std::vector< int > x0_ = std::vector< int >();  // Swig output
+        std::vector< int > x1_ = std::vector< int >();  // Swig output
+
+        obj->get_crs(x0_, x1_);
+        *x0 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_diag" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_diag"
+// cWrapperName: "casadi__Sparsity__get_diag"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__get_diag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0)"
+// call: "        casadi::Sparsity ret = obj->get_diag(x0_);"
+// params: [(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__get_diag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0);
+casadi::Sparsity*
+    casadi__Sparsity__get_diag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0){
+    try {
+        std::vector< int > x0_ = std::vector< int >();  // Swig output
+
+        casadi::Sparsity ret = obj->get_diag(x0_);
+        *x0 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x0_ );
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_lower" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_lower"
+// cWrapperName: "casadi__Sparsity__get_lower"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__get_lower(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->get_lower();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__get_lower(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__get_lower(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->get_lower();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_nz"
+// cWrapperName: "casadi__Sparsity__get_nz__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__get_nz__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// call: "        obj->get_nz(x0_);"
+// params: [(Ref (StdVec CInt),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__get_nz__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
+void
+    casadi__Sparsity__get_nz__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        obj->get_nz(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_nz"
+// cWrapperName: "casadi__Sparsity__get_nz__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// args: "(x0_, x1_)"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__get_nz__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
+// call: "        std::vector< int > ret = obj->get_nz(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__get_nz__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
+std::vector< int >*
+    casadi__Sparsity__get_nz__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+
+        std::vector< int > ret = obj->get_nz(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_nz" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_nz"
+// cWrapperName: "casadi__Sparsity__get_nz__2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__get_nz__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// call: "        int ret = obj->get_nz(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__get_nz__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
+int
+    casadi__Sparsity__get_nz__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        int ret = obj->get_nz(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_row" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_row"
+// cWrapperName: "casadi__Sparsity__get_row"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__get_row(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->get_row();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__get_row(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__get_row(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->get_row();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "get_triplet" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_triplet"
+// cWrapperName: "casadi__Sparsity__get_triplet"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__get_triplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// call: "        obj->get_triplet(x0_, x1_);"
+// params: [(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+void
+    casadi__Sparsity__get_triplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1);
+void
+    casadi__Sparsity__get_triplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1){
+    try {
+        std::vector< int > x0_ = std::vector< int >();  // Swig output
+        std::vector< int > x1_ = std::vector< int >();  // Swig output
+
+        obj->get_triplet(x0_, x1_);
+        *x0 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x1_ );
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "get_upper" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::get_upper"
+// cWrapperName: "casadi__Sparsity__get_upper"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__get_upper(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->get_upper();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__get_upper(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__get_upper(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->get_upper();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "has_nz" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::has_nz"
+// cWrapperName: "casadi__Sparsity__has_nz"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__has_nz(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// call: "        bool ret = obj->has_nz(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__has_nz(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
+int
+    casadi__Sparsity__has_nz(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        bool ret = obj->has_nz(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "hash" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::hash"
+// cWrapperName: "casadi__Sparsity__hash"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CSize
+// cWrapperRetType: "size_t"
+// proto: "size_t\n    casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        size_t ret = obj->hash();"
+// params: []
+extern "C"
+size_t
+    casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj);
+size_t
+    casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        size_t ret = obj->hash();
+
+        return WrapReturn< size_t, size_t >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "intersect" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::intersect"
+// cWrapperName: "casadi__Sparsity__intersect"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__intersect(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        casadi::Sparsity ret = obj->intersect(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__intersect(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+casadi::Sparsity*
+    casadi__Sparsity__intersect(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->intersect(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "isReshape" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::isReshape"
+// cWrapperName: "casadi__Sparsity__isReshape"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        bool ret = obj->isReshape(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+int
+    casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        bool ret = obj->isReshape(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_column" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_column"
+// cWrapperName: "casadi__Sparsity__is_column"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_column(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_column();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_column(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_column(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_column();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_dense" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_dense"
+// cWrapperName: "casadi__Sparsity__is_dense"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_dense(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_dense();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_dense(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_dense(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_dense();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_diag" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_diag"
+// cWrapperName: "casadi__Sparsity__is_diag"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_diag(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_diag();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_diag(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_diag(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_diag();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_empty"
+// cWrapperName: "casadi__Sparsity__is_empty__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_empty__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_empty();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_empty__0(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_empty__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_empty();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_empty" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_empty"
+// cWrapperName: "casadi__Sparsity__is_empty__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_empty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        bool ret = obj->is_empty(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__is_empty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__is_empty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_empty(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_equal" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_equal"
+// cWrapperName: "casadi__Sparsity__is_equal__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_equal__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        bool ret = obj->is_equal(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__is_equal__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+int
+    casadi__Sparsity__is_equal__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        bool ret = obj->is_equal(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_equal" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_equal"
+// cWrapperName: "casadi__Sparsity__is_equal__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_equal__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        bool ret = obj->is_equal(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__is_equal__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+int
+    casadi__Sparsity__is_equal__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        bool ret = obj->is_equal(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_row" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_row"
+// cWrapperName: "casadi__Sparsity__is_row"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_row(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_row();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_row(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_row(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_row();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_scalar"
+// cWrapperName: "casadi__Sparsity__is_scalar__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_scalar__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_scalar();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_scalar__0(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_scalar__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_scalar();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_scalar" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_scalar"
+// cWrapperName: "casadi__Sparsity__is_scalar__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_scalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        bool ret = obj->is_scalar(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__is_scalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__is_scalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->is_scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_singular" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_singular"
+// cWrapperName: "casadi__Sparsity__is_singular"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_singular(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_singular();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_singular(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_singular(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_singular();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_square" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_square"
+// cWrapperName: "casadi__Sparsity__is_square"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_square(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_square();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_square(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_square(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_square();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_symmetric" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_symmetric"
+// cWrapperName: "casadi__Sparsity__is_symmetric"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_symmetric(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_symmetric();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_symmetric(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_symmetric(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_symmetric();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_transpose" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_transpose"
+// cWrapperName: "casadi__Sparsity__is_transpose"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_transpose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        bool ret = obj->is_transpose(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__is_transpose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+int
+    casadi__Sparsity__is_transpose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        bool ret = obj->is_transpose(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_tril" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_tril"
+// cWrapperName: "casadi__Sparsity__is_tril"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_tril(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_tril();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_tril(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_tril(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_tril();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_triu" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_triu"
+// cWrapperName: "casadi__Sparsity__is_triu"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_triu(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_triu();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_triu(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_triu(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_triu();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "is_vector" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::is_vector"
+// cWrapperName: "casadi__Sparsity__is_vector"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__is_vector(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->is_vector();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__is_vector(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__is_vector(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->is_vector();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "largest_first" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::largest_first"
+// cWrapperName: "casadi__Sparsity__largest_first"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdVec CInt
+// cWrapperRetType: "std::vector< int >*"
+// proto: "std::vector< int >*\n    casadi__Sparsity__largest_first(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::vector< int > ret = obj->largest_first();"
+// params: []
+extern "C"
+std::vector< int >*
+    casadi__Sparsity__largest_first(std::string ** err_msg, casadi::Sparsity* obj);
+std::vector< int >*
+    casadi__Sparsity__largest_first(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::vector< int > ret = obj->largest_first();
+
+        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "lower" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::lower"
+// cWrapperName: "casadi__Sparsity__lower"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__lower(std::string ** err_msg, int x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::lower(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__lower(std::string ** err_msg, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__lower(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::lower(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "makeDense" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::makeDense"
+// cWrapperName: "casadi__Sparsity__makeDense"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// call: "        casadi::Sparsity ret = obj->makeDense(x0_);"
+// params: [(Ref (StdVec CInt),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
+casadi::Sparsity*
+    casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->makeDense(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::nnz"
+// cWrapperName: "casadi__Sparsity__nnz"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__nnz(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->nnz();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__nnz(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__nnz(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->nnz();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_diag" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::nnz_diag"
+// cWrapperName: "casadi__Sparsity__nnz_diag"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__nnz_diag(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->nnz_diag();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__nnz_diag(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__nnz_diag(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->nnz_diag();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_lower" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::nnz_lower"
+// cWrapperName: "casadi__Sparsity__nnz_lower__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__nnz_lower__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->nnz_lower();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__nnz_lower__0(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__nnz_lower__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->nnz_lower();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_lower" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::nnz_lower"
+// cWrapperName: "casadi__Sparsity__nnz_lower__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__nnz_lower__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        int ret = obj->nnz_lower(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__nnz_lower__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__nnz_lower__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        int ret = obj->nnz_lower(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_upper" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::nnz_upper"
+// cWrapperName: "casadi__Sparsity__nnz_upper__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__nnz_upper__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->nnz_upper();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__nnz_upper__0(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__nnz_upper__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->nnz_upper();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "nnz_upper" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::nnz_upper"
+// cWrapperName: "casadi__Sparsity__nnz_upper__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__nnz_upper__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        int ret = obj->nnz_upper(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__nnz_upper__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__nnz_upper__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        int ret = obj->nnz_upper(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "numel" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::numel"
+// cWrapperName: "casadi__Sparsity__numel"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->numel();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->numel();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator !=" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::operator !="
+// cWrapperName: "casadi__Sparsity__operator__nequals"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__operator__nequals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        bool ret = obj->operator !=(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__operator__nequals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+int
+    casadi__Sparsity__operator__nequals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        bool ret = obj->operator !=(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator *" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::operator *"
+// cWrapperName: "casadi__Sparsity__operator__mul"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__operator__mul(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        casadi::Sparsity ret = obj->operator *(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__operator__mul(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+casadi::Sparsity*
+    casadi__Sparsity__operator__mul(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->operator *(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator +" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::operator +"
+// cWrapperName: "casadi__Sparsity__operator__plus"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__operator__plus(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        casadi::Sparsity ret = obj->operator +(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__operator__plus(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+casadi::Sparsity*
+    casadi__Sparsity__operator__plus(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->operator +(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "operator ==" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::operator =="
+// cWrapperName: "casadi__Sparsity__operator__equals"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__operator__equals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        bool ret = obj->operator ==(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__operator__equals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+int
+    casadi__Sparsity__operator__equals(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        bool ret = obj->operator ==(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "pattern_inverse" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::pattern_inverse"
+// cWrapperName: "casadi__Sparsity__pattern_inverse"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__pattern_inverse(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        casadi::Sparsity ret = obj->pattern_inverse();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__pattern_inverse(std::string ** err_msg, casadi::Sparsity* obj);
+casadi::Sparsity*
+    casadi__Sparsity__pattern_inverse(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        casadi::Sparsity ret = obj->pattern_inverse();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "pmult" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::pmult"
+// cWrapperName: "casadi__Sparsity__pmult__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// call: "        casadi::Sparsity ret = obj->pmult(x0_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
+casadi::Sparsity*
+    casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->pmult(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "pmult" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::pmult"
+// cWrapperName: "casadi__Sparsity__pmult__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->pmult(x0_, x1_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->pmult(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "pmult" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::pmult"
+// cWrapperName: "casadi__Sparsity__pmult__2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
+// call: "        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2);
+casadi::Sparsity*
+    casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+
+        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "pmult" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::pmult"
+// cWrapperName: "casadi__Sparsity__pmult__3"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
+// call: "        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3);
+casadi::Sparsity*
+    casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+        bool x2_ = Marshaling<bool,int>::marshal(x2);
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "print_compact" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::print_compact"
+// cWrapperName: "casadi__Sparsity__print_compact"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__print_compact(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        obj->print_compact();"
+// params: []
+extern "C"
+void
+    casadi__Sparsity__print_compact(std::string ** err_msg, casadi::Sparsity* obj);
+void
+    casadi__Sparsity__print_compact(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        obj->print_compact();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "removeDuplicates" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::removeDuplicates"
+// cWrapperName: "casadi__Sparsity__removeDuplicates"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// call: "        obj->removeDuplicates(x0_);"
+// params: [(Ref (StdVec CInt),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
+void
+    casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        obj->removeDuplicates(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "resize" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::resize"
+// cWrapperName: "casadi__Sparsity__resize"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// call: "        obj->resize(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
+void
+    casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        obj->resize(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "row" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::row"
+// cWrapperName: "casadi__Sparsity__row"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__row(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        int ret = obj->row(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__row(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__row(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->row(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "rowcol" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::rowcol"
+// cWrapperName: "casadi__Sparsity__rowcol"
+// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::rowcol(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3);
+casadi::Sparsity*
+    casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        casadi::Sparsity ret = casadi::Sparsity::rowcol(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "rowsSequential" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::rowsSequential"
+// cWrapperName: "casadi__Sparsity__rowsSequential__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        bool ret = obj->rowsSequential();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        bool ret = obj->rowsSequential();
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "rowsSequential" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::rowsSequential"
+// cWrapperName: "casadi__Sparsity__rowsSequential__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CBool
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        bool ret = obj->rowsSequential(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        bool ret = obj->rowsSequential(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, bool >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::sanity_check"
+// cWrapperName: "casadi__Sparsity__sanity_check__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__sanity_check__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        obj->sanity_check();"
+// params: []
+extern "C"
+void
+    casadi__Sparsity__sanity_check__0(std::string ** err_msg, casadi::Sparsity* obj);
+void
+    casadi__Sparsity__sanity_check__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        obj->sanity_check();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "sanity_check" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::sanity_check"
+// cWrapperName: "casadi__Sparsity__sanity_check__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__sanity_check__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        obj->sanity_check(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__sanity_check__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+void
+    casadi__Sparsity__sanity_check__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        obj->sanity_check(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Static method: "scalar" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::scalar"
+// cWrapperName: "casadi__Sparsity__scalar__0"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__scalar__0(std::string ** err_msg)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::scalar();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__scalar__0(std::string ** err_msg);
+casadi::Sparsity*
+    casadi__Sparsity__scalar__0(std::string ** err_msg){
+    try {
+
+        casadi::Sparsity ret = casadi::Sparsity::scalar();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "scalar" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::scalar"
+// cWrapperName: "casadi__Sparsity__scalar__1"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__scalar__1(std::string ** err_msg, int x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::scalar(x0_);"
+// params: [(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__scalar__1(std::string ** err_msg, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__scalar__1(std::string ** err_msg, int x0){
+    try {
+        bool x0_ = Marshaling<bool,int>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::scalar(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "scc" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::scc"
+// cWrapperName: "casadi__Sparsity__scc"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// args: "(x0_, x1_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__scc(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1)"
+// call: "        int ret = obj->scc(x0_, x1_);"
+// params: [(Ref (StdVec CInt),SwigOutput True),(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+int
+    casadi__Sparsity__scc(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1);
+int
+    casadi__Sparsity__scc(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >** x0, std::vector< int >** x1){
+    try {
+        std::vector< int > x0_ = std::vector< int >();  // Swig output
+        std::vector< int > x1_ = std::vector< int >();  // Swig output
+
+        int ret = obj->scc(x0_, x1_);
+        *x0 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x0_ );
+        *x1 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x1_ );
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::size"
+// cWrapperName: "casadi__Sparsity__size__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__size__0(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        int ret = obj->size(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+int
+    casadi__Sparsity__size__0(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+int
+    casadi__Sparsity__size__0(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        int ret = obj->size(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::size"
+// cWrapperName: "casadi__Sparsity__size__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: StdPair CInt CInt
+// cWrapperRetType: "std::pair< int, int >*"
+// proto: "std::pair< int, int >*\n    casadi__Sparsity__size__1(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        std::pair< int, int > ret = obj->size();"
+// params: []
+extern "C"
+std::pair< int, int >*
+    casadi__Sparsity__size__1(std::string ** err_msg, casadi::Sparsity* obj);
+std::pair< int, int >*
+    casadi__Sparsity__size__1(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        std::pair< int, int > ret = obj->size();
+
+        return WrapReturn< std::pair< int, int >*, std::pair< int, int > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size1" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::size1"
+// cWrapperName: "casadi__Sparsity__size1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->size1();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->size1();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "size2" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::size2"
+// cWrapperName: "casadi__Sparsity__size2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CInt
+// cWrapperRetType: "int"
+// proto: "int\n    casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        int ret = obj->size2();"
+// params: []
+extern "C"
+int
+    casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj);
+int
+    casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        int ret = obj->size2();
+
+        return WrapReturn< int, int >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "spy" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::spy"
+// cWrapperName: "casadi__Sparsity__spy"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        obj->spy();"
+// params: []
+extern "C"
+void
+    casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj);
+void
+    casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        obj->spy();
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "spy_matlab" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::spy_matlab"
+// cWrapperName: "casadi__Sparsity__spy_matlab"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__Sparsity__spy_matlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0)"
+// call: "        obj->spy_matlab(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__Sparsity__spy_matlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0);
+void
+    casadi__Sparsity__spy_matlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        obj->spy_matlab(x0_);
+        // x0 is not a swig output
+
+        return;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return;
+    }
+}
+
+
+// ================== Normal method: "star_coloring" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::star_coloring"
+// cWrapperName: "casadi__Sparsity__star_coloring__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__star_coloring__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        casadi::Sparsity ret = obj->star_coloring();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring__0(std::string ** err_msg, casadi::Sparsity* obj);
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        casadi::Sparsity ret = obj->star_coloring();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "star_coloring" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::star_coloring"
+// cWrapperName: "casadi__Sparsity__star_coloring__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__star_coloring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->star_coloring(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->star_coloring(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "star_coloring" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::star_coloring"
+// cWrapperName: "casadi__Sparsity__star_coloring__2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__star_coloring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->star_coloring(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->star_coloring(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "star_coloring2" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::star_coloring2"
+// cWrapperName: "casadi__Sparsity__star_coloring2__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__star_coloring2__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        casadi::Sparsity ret = obj->star_coloring2();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring2__0(std::string ** err_msg, casadi::Sparsity* obj);
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring2__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        casadi::Sparsity ret = obj->star_coloring2();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "star_coloring2" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::star_coloring2"
+// cWrapperName: "casadi__Sparsity__star_coloring2__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__star_coloring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
+// call: "        casadi::Sparsity ret = obj->star_coloring2(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = obj->star_coloring2(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "star_coloring2" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::star_coloring2"
+// cWrapperName: "casadi__Sparsity__star_coloring2__2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__star_coloring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->star_coloring2(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__star_coloring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->star_coloring2(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sub" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::sub"
+// cWrapperName: "casadi__Sparsity__sub__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2)"
+// call: "        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__sub__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2);
+casadi::Sparsity*
+    casadi__Sparsity__sub__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        std::vector< int > x2_ = std::vector< int >();  // Swig output
+
+        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        *x2 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x2_ );
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sub" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::sub"
+// cWrapperName: "casadi__Sparsity__sub__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2, int x3)"
+// call: "        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(Ref (StdVec CInt),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__sub__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2, int x3);
+casadi::Sparsity*
+    casadi__Sparsity__sub__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, casadi::Sparsity* x1, std::vector< int >** x2, int x3){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+        std::vector< int > x2_ = std::vector< int >();  // Swig output
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        *x2 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x2_ );
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sub" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::sub"
+// cWrapperName: "casadi__Sparsity__sub__2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2)"
+// args: "(x0_, x1_, x2_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2)"
+// call: "        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (StdVec CInt),SwigOutput True)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__sub__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2);
+casadi::Sparsity*
+    casadi__Sparsity__sub__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        std::vector< int > x2_ = std::vector< int >();  // Swig output
+
+        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        *x2 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x2_ );
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "sub" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::sub"
+// cWrapperName: "casadi__Sparsity__sub__3"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2, int x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__sub__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2, int x3)"
+// call: "        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_, x3_);"
+// params: [(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (StdVec CInt),SwigOutput True),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__sub__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2, int x3);
+casadi::Sparsity*
+    casadi__Sparsity__sub__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >** x2, int x3){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
+        std::vector< int > x2_ = std::vector< int >();  // Swig output
+        bool x3_ = Marshaling<bool,int>::marshal(x3);
+
+        casadi::Sparsity ret = obj->sub(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        *x2 = WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( x2_ );
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "transpose" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::transpose"
+// cWrapperName: "casadi__Sparsity__transpose__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
+// call: "        casadi::Sparsity ret = obj->transpose(x0_);"
+// params: [(Ref (StdVec CInt),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
+casadi::Sparsity*
+    casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->transpose(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "transpose" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::transpose"
+// cWrapperName: "casadi__Sparsity__transpose__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->transpose(x0_, x1_);"
+// params: [(Ref (StdVec CInt),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
+    try {
+        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
+        bool x1_ = Marshaling<bool,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->transpose(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::triplet"
+// cWrapperName: "casadi__Sparsity__triplet__0"
+// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// args: "(x0_, x1_, x2_, x3_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
+casadi::Sparsity*
+    casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+
+        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::triplet"
+// cWrapperName: "casadi__Sparsity__triplet__1"
+// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4)"
+// args: "(x0_, x1_, x2_, x3_, x4_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (StdVec CInt),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4);
+casadi::Sparsity*
+    casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
+
+        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "triplet" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::triplet"
+// cWrapperName: "casadi__Sparsity__triplet__2"
+// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_, x5_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (Const (StdVec CInt)),SwigOutput False),(Ref (StdVec CInt),SwigOutput False),(CBool,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5);
+casadi::Sparsity*
+    casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
+        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
+        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
+        bool x5_ = Marshaling<bool,int>::marshal(x5);
+
+        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_, x5_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+        // x2 is not a swig output
+        // x3 is not a swig output
+        // x4 is not a swig output
+        // x5 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "uni_coloring" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::uni_coloring"
+// cWrapperName: "casadi__Sparsity__uni_coloring__0"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__uni_coloring__0(std::string ** err_msg, casadi::Sparsity* obj)"
+// call: "        casadi::Sparsity ret = obj->uni_coloring();"
+// params: []
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__uni_coloring__0(std::string ** err_msg, casadi::Sparsity* obj);
+casadi::Sparsity*
+    casadi__Sparsity__uni_coloring__0(std::string ** err_msg, casadi::Sparsity* obj){
+    try {
+
+        casadi::Sparsity ret = obj->uni_coloring();
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "uni_coloring" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::uni_coloring"
+// cWrapperName: "casadi__Sparsity__uni_coloring__1"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__uni_coloring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        casadi::Sparsity ret = obj->uni_coloring(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__uni_coloring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+casadi::Sparsity*
+    casadi__Sparsity__uni_coloring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->uni_coloring(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "uni_coloring" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::uni_coloring"
+// cWrapperName: "casadi__Sparsity__uni_coloring__2"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__uni_coloring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1)"
+// call: "        casadi::Sparsity ret = obj->uni_coloring(x0_, x1_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__uni_coloring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__uni_coloring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = obj->uni_coloring(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "unit" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::unit"
+// cWrapperName: "casadi__Sparsity__unit"
+// protoArgs: "(std::string ** err_msg, int x0, int x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::unit(x0_, x1_);"
+// params: [(CInt,SwigOutput False),(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1);
+casadi::Sparsity*
+    casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        int x1_ = Marshaling<int,int>::marshal(x1);
+
+        casadi::Sparsity ret = casadi::Sparsity::unit(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "unite" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::unite"
+// cWrapperName: "casadi__Sparsity__unite"
+// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__unite(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
+// call: "        casadi::Sparsity ret = obj->unite(x0_);"
+// params: [(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__unite(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
+casadi::Sparsity*
+    casadi__Sparsity__unite(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
+    try {
+        casadi::Sparsity& x0_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x0);
+
+        casadi::Sparsity ret = obj->unite(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "upper" ===============
+// class: "casadi::Sparsity"
+// cppName: "casadi::Sparsity::upper"
+// cWrapperName: "casadi__Sparsity__upper"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
+// cWrapperRetType: "casadi::Sparsity*"
+// proto: "casadi::Sparsity*\n    casadi__Sparsity__upper(std::string ** err_msg, int x0)"
+// call: "        casadi::Sparsity ret = casadi::Sparsity::upper(x0_);"
+// params: [(CInt,SwigOutput False)]
+extern "C"
+casadi::Sparsity*
+    casadi__Sparsity__upper(std::string ** err_msg, int x0);
+casadi::Sparsity*
+    casadi__Sparsity__upper(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        casadi::Sparsity ret = casadi::Sparsity::upper(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "SparsityInterfaceCommon")===============
+// classType: UserType (Namespace ["casadi"]) (Name "SparsityInterfaceCommon")
+extern "C"
+void delete_casadi__SparsityInterfaceCommon(casadi::SparsityInterfaceCommon* obj);
+void delete_casadi__SparsityInterfaceCommon(casadi::SparsityInterfaceCommon* obj){
+    delete obj;
+}
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "Variable")===============
+// classType: UserType (Namespace ["casadi"]) (Name "Variable")
+extern "C"
+void delete_casadi__Variable(casadi::Variable* obj);
+void delete_casadi__Variable(casadi::Variable* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Variable"
+// cppName: "casadi::Variable"
+// cWrapperName: "casadi__Variable__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
+// cWrapperRetType: "casadi::Variable*"
+// proto: "casadi::Variable*\n    casadi__Variable__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::Variable* ret = (casadi::Variable*)new casadi::Variable(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::Variable*
+    casadi__Variable__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0);
+casadi::Variable*
+    casadi__Variable__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::Variable* ret = (casadi::Variable*)new casadi::Variable(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Variable"
+// cppName: "casadi::Variable"
+// cWrapperName: "casadi__Variable__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// args: "(x0_, x1_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
+// cWrapperRetType: "casadi::Variable*"
+// proto: "casadi::Variable*\n    casadi__Variable__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
+// call: "        casadi::Variable* ret = (casadi::Variable*)new casadi::Variable(x0_, x1_);"
+// params: [(Ref (Const StdString),SwigOutput False),(Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),SwigOutput False)]
+extern "C"
+casadi::Variable*
+    casadi__Variable__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
+casadi::Variable*
+    casadi__Variable__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+        casadi::Sparsity& x1_ = Marshaling<casadi::Sparsity&,casadi::Sparsity*>::marshal(x1);
+
+        casadi::Variable* ret = (casadi::Variable*)new casadi::Variable(x0_, x1_);
+        // x0 is not a swig output
+        // x1 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::Variable"
+// cppName: "casadi::Variable"
+// cWrapperName: "casadi__Variable__CONSTRUCTOR__2"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "Variable")
+// cWrapperRetType: "casadi::Variable*"
+// proto: "casadi::Variable*\n    casadi__Variable__CONSTRUCTOR__2(std::string ** err_msg)"
+// call: "        casadi::Variable* ret = (casadi::Variable*)new casadi::Variable();"
+// params: []
+extern "C"
+casadi::Variable*
+    casadi__Variable__CONSTRUCTOR__2(std::string ** err_msg);
+casadi::Variable*
+    casadi__Variable__CONSTRUCTOR__2(std::string ** err_msg){
+    try {
+
+        casadi::Variable* ret = (casadi::Variable*)new casadi::Variable();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "name" ===============
+// class: "casadi::Variable"
+// cppName: "casadi::Variable::name"
+// cWrapperName: "casadi__Variable__name"
+// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj)"
+// call: "        std::string ret = obj->name();"
+// params: []
+extern "C"
+std::string*
+    casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj);
+std::string*
+    casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj){
+    try {
+
+        std::string ret = obj->name();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getRepresentation" ===============
+// class: "casadi::Variable"
+// cppName: "casadi::Variable::getRepresentation"
+// cWrapperName: "casadi__Variable__getRepresentation"
+// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj)"
+// call: "        std::string ret = obj->getRepresentation();"
+// params: []
+extern "C"
+std::string*
+    casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj);
+std::string*
+    casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj){
+    try {
+
+        std::string ret = obj->getRepresentation();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Normal method: "getDescription" ===============
+// class: "casadi::Variable"
+// cppName: "casadi::Variable::getDescription"
+// cWrapperName: "casadi__Variable__getDescription"
+// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
+// args: "()"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj)"
+// call: "        std::string ret = obj->getDescription();"
+// params: []
+extern "C"
+std::string*
+    casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj);
+std::string*
+    casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj){
+    try {
+
+        std::string ret = obj->getDescription();
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+
+// ================== delete UserType (Namespace ["casadi"]) (Name "XmlFile")===============
+// classType: UserType (Namespace ["casadi"]) (Name "XmlFile")
+extern "C"
+void delete_casadi__XmlFile(casadi::XmlFile* obj);
+void delete_casadi__XmlFile(casadi::XmlFile* obj){
+    delete obj;
+}
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::XmlFile"
+// cppName: "casadi::XmlFile"
+// cWrapperName: "casadi__XmlFile__CONSTRUCTOR__0"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: UserType (Namespace ["casadi"]) (Name "XmlFile")
+// cWrapperRetType: "casadi::XmlFile*"
+// proto: "casadi::XmlFile*\n    casadi__XmlFile__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::XmlFile* ret = (casadi::XmlFile*)new casadi::XmlFile(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+casadi::XmlFile*
+    casadi__XmlFile__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0);
+casadi::XmlFile*
+    casadi__XmlFile__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::XmlFile* ret = (casadi::XmlFile*)new casadi::XmlFile(x0_);
+        // x0 is not a swig output
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Constructor method: "CONSTRUCTOR" ===============
+// class: "casadi::XmlFile"
+// cppName: "casadi::XmlFile"
+// cWrapperName: "casadi__XmlFile__CONSTRUCTOR__1"
+// protoArgs: "(std::string ** err_msg)"
+// args: "()"
+// rettype: UserType (Namespace ["casadi"]) (Name "XmlFile")
+// cWrapperRetType: "casadi::XmlFile*"
+// proto: "casadi::XmlFile*\n    casadi__XmlFile__CONSTRUCTOR__1(std::string ** err_msg)"
+// call: "        casadi::XmlFile* ret = (casadi::XmlFile*)new casadi::XmlFile();"
+// params: []
+extern "C"
+casadi::XmlFile*
+    casadi__XmlFile__CONSTRUCTOR__1(std::string ** err_msg);
+casadi::XmlFile*
+    casadi__XmlFile__CONSTRUCTOR__1(std::string ** err_msg){
+    try {
+
+        casadi::XmlFile* ret = (casadi::XmlFile*)new casadi::XmlFile();
+
+        return ret;
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "doc" ===============
+// class: "casadi::XmlFile"
+// cppName: "casadi::XmlFile::doc"
+// cWrapperName: "casadi__XmlFile__doc"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: StdString
+// cWrapperRetType: "std::string*"
+// proto: "std::string*\n    casadi__XmlFile__doc(std::string ** err_msg, std::string* x0)"
+// call: "        std::string ret = casadi::XmlFile::doc(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+std::string*
+    casadi__XmlFile__doc(std::string ** err_msg, std::string* x0);
+std::string*
+    casadi__XmlFile__doc(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        std::string ret = casadi::XmlFile::doc(x0_);
+        // x0 is not a swig output
+
+        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== Static method: "loadPlugin" ===============
+// class: "casadi::XmlFile"
+// cppName: "casadi::XmlFile::loadPlugin"
+// cWrapperName: "casadi__XmlFile__loadPlugin"
+// protoArgs: "(std::string ** err_msg, std::string* x0)"
+// args: "(x0_)"
+// rettype: CVoid
+// cWrapperRetType: "void"
+// proto: "void\n    casadi__XmlFile__loadPlugin(std::string ** err_msg, std::string* x0)"
+// call: "        casadi::XmlFile::loadPlugin(x0_);"
+// params: [(Ref (Const StdString),SwigOutput False)]
+extern "C"
+void
+    casadi__XmlFile__loadPlugin(std::string ** err_msg, std::string* x0);
+void
+    casadi__XmlFile__loadPlugin(std::string ** err_msg, std::string* x0){
+    try {
+        std::string& x0_ = Marshaling<std::string&,std::string*>::marshal(x0);
+
+        casadi::XmlFile::loadPlugin(x0_);
+        // x0 is not a swig output
+
+        return;
     } catch (std::exception& ex) {
          *err_msg = new std::string(ex.what());
          return;
diff --git a/cbits/autogen/casadi_wrap_functions.cpp b/cbits/autogen/casadi_wrap_functions.cpp
# file too large to diff: cbits/autogen/casadi_wrap_functions.cpp